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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
PulseCore.Action.fst | PulseCore.Action.frame | val frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre ** frame) (fun x -> post x ** frame) | val frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre ** frame) (fun x -> post x ** frame) | let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 37,
"end_line": 168,
"start_col": 0,
"start_line": 162
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: PulseCore.Action.act a opens pre post
-> PulseCore.Action.act a opens (pre ** frame) (fun x -> post x ** frame) | Prims.Tot | [
"total"
] | [] | [
"PulseCore.Action.inames",
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Action.act",
"PulseCore.Action.inames_disj",
"PulseCore.Action.frame_action",
"PulseCore.Action.action",
"PulseCore.Memory.star",
"PulseCore.InstantiatedSemantics.op_Star_Star"
] | [] | false | false | false | false | false | let frame (#a: Type u#a) (#opens: inames) (#pre #post #frame: _) (f: act a opens pre post)
: act a opens (pre `star` frame) (fun x -> (post x) `star` frame) =
| fun #ictx -> frame_action (f #ictx) | false |
PulseCore.Action.fst | PulseCore.Action.bind | val bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2 | val bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2 | let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 89,
"end_line": 160,
"start_col": 0,
"start_line": 152
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: PulseCore.Action.act a opens pre1 post1 ->
g: (x: a -> PulseCore.Action.act b opens (post1 x) post2)
-> PulseCore.Action.act b opens pre1 post2 | Prims.Tot | [
"total"
] | [] | [
"PulseCore.Action.inames",
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Action.act",
"PulseCore.Action.inames_disj",
"PulseCore.Action.bind_action",
"PulseCore.Action.action"
] | [] | false | false | false | false | false | let bind
(#a: Type u#a)
(#b: Type u#b)
(#opens: inames)
(#pre1 #post1 #post2: _)
(f: act a opens pre1 post1)
(g: (x: a -> act b opens (post1 x) post2))
: act b opens pre1 post2 =
| fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx) | false |
PulseCore.Action.fst | PulseCore.Action.new_invariant | val new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp) | val new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp) | let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 55,
"end_line": 222,
"start_col": 0,
"start_line": 219
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: PulseCore.InstantiatedSemantics.slprop
-> PulseCore.Action.act (PulseCore.Action.inv p)
PulseCore.Action.emp_inames
p
(fun _ -> PulseCore.InstantiatedSemantics.emp) | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Action.inames_disj",
"PulseCore.Action.emp_inames",
"PulseCore.Action.mem_action_as_action",
"PulseCore.Memory.inv",
"PulseCore.Memory.emp",
"PulseCore.Memory.new_invariant",
"PulseCore.Action.action",
"PulseCore.Action.inv",
"PulseCore.InstantiatedSemantics.emp",
"PulseCore.Action.act"
] | [] | false | false | false | false | false | let new_invariant (p: slprop) : act (inv p) emp_inames p (fun _ -> emp) =
| fun #ictx -> mem_action_as_action _ _ _ _ (new_invariant ictx p) | false |
PulseCore.Action.fst | PulseCore.Action.inv | val inv (p:slprop) : Type0 | val inv (p:slprop) : Type0 | let inv = inv | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 13,
"end_line": 216,
"start_col": 0,
"start_line": 216
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
/////////////////////////////////////////////////////// | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: PulseCore.InstantiatedSemantics.slprop -> Type0 | Prims.Tot | [
"total"
] | [] | [
"PulseCore.Memory.inv"
] | [] | false | false | false | true | true | let inv =
| inv | false |
PulseCore.Action.fst | PulseCore.Action.ref_null | val ref_null (#a:Type u#a) (p:pcm a) : ref a p | val ref_null (#a:Type u#a) (p:pcm a) : ref a p | let ref_null (#a:Type u#a) (p:pcm a) = core_ref_null | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 52,
"end_line": 245,
"start_col": 0,
"start_line": 245
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p)
let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m
///////////////////////////////////////////////////////////////////
// Core operations on references
/////////////////////////////////////////////////////////////////// | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: FStar.PCM.pcm a -> PulseCore.Action.ref a p | Prims.Tot | [
"total"
] | [] | [
"FStar.PCM.pcm",
"PulseCore.Memory.core_ref_null",
"PulseCore.Action.ref"
] | [] | false | false | false | false | false | let ref_null (#a: Type u#a) (p: pcm a) =
| core_ref_null | false |
PulseCore.Action.fst | PulseCore.Action.ref | val ref ([@@@unused] a:Type u#a) ([@@@unused] p:pcm a) : Type u#0 | val ref ([@@@unused] a:Type u#a) ([@@@unused] p:pcm a) : Type u#0 | let ref (a:Type u#a) (p:pcm a) = ref a p | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 40,
"end_line": 244,
"start_col": 0,
"start_line": 244
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p)
let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m
///////////////////////////////////////////////////////////////////
// Core operations on references
/////////////////////////////////////////////////////////////////// | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Type -> p: FStar.PCM.pcm a -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.PCM.pcm",
"PulseCore.Memory.ref"
] | [] | false | false | false | true | true | let ref (a: Type u#a) (p: pcm a) =
| ref a p | false |
PulseCore.Action.fst | PulseCore.Action.name_of_inv | val name_of_inv #p (i:inv p) : GTot iname | val name_of_inv #p (i:inv p) : GTot iname | let name_of_inv = name_of_inv | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 29,
"end_line": 217,
"start_col": 0,
"start_line": 217
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
/////////////////////////////////////////////////////// | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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 | i: PulseCore.Action.inv p -> Prims.GTot PulseCore.Action.iname | Prims.GTot | [
"sometrivial"
] | [] | [
"PulseCore.Memory.name_of_inv"
] | [] | false | false | false | false | false | let name_of_inv =
| name_of_inv | false |
PulseCore.Action.fst | PulseCore.Action.pts_to | val pts_to (#a:Type u#1) (#p:pcm a) (r:ref a p) (v:a) : slprop | val pts_to (#a:Type u#1) (#p:pcm a) (r:ref a p) (v:a) : slprop | let pts_to = pts_to | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 19,
"end_line": 247,
"start_col": 0,
"start_line": 247
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p)
let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m
///////////////////////////////////////////////////////////////////
// Core operations on references
///////////////////////////////////////////////////////////////////
let ref (a:Type u#a) (p:pcm a) = ref a p
let ref_null (#a:Type u#a) (p:pcm a) = core_ref_null | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: PulseCore.Action.ref a p -> v: a -> PulseCore.InstantiatedSemantics.slprop | Prims.Tot | [
"total"
] | [] | [
"PulseCore.Memory.pts_to"
] | [] | false | false | false | false | false | let pts_to =
| pts_to | false |
PulseCore.Action.fst | PulseCore.Action.return_action | val return_action (#a: Type u#a) (#except: inames) (#post: (a -> slprop)) (x: a)
: action a except (post x) post | val return_action (#a: Type u#a) (#except: inames) (#post: (a -> slprop)) (x: a)
: action a except (post x) post | let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 36,
"end_line": 38,
"start_col": 0,
"start_line": 32
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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 -> PulseCore.Action.action a except (post x) post | Prims.Tot | [
"total"
] | [] | [
"PulseCore.Memory.inames",
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.MonotonicStateMonad.weaken",
"PulseCore.Semantics.full_mem",
"PulseCore.InstantiatedSemantics.state",
"PulseCore.Semantics.__proj__Mkstate__item__evolves",
"Prims.l_True",
"Prims.prop",
"Prims.l_and",
"Prims.eq2",
"PulseCore.Memory.inames_ok",
"PulseCore.Semantics.__proj__Mkstate__item__interp",
"PulseCore.Semantics.__proj__Mkstate__item__star",
"PulseCore.Memory.star",
"PulseCore.Semantics.__proj__Mkstate__item__invariant",
"PulseCore.InstantiatedSemantics.state0",
"PulseCore.MonotonicStateMonad.return",
"PulseCore.Semantics.mst_sep_aux",
"PulseCore.Semantics.__proj__Mkstate__item__pred",
"PulseCore.Action.action"
] | [] | false | false | false | false | false | let return_action (#a: Type u#a) (#except: inames) (#post: (a -> slprop)) (x: a)
: action a except (post x) post =
| fun frame -> M.weaken (M.return x) | false |
PulseCore.Action.fst | PulseCore.Action.write | val write
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x y:Ghost.erased a)
(f:FStar.PCM.frame_preserving_upd p x y)
: act unit emp_inames
(pts_to r x)
(fun _ -> pts_to r y) | val write
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x y:Ghost.erased a)
(f:FStar.PCM.frame_preserving_upd p x y)
: act unit emp_inames
(pts_to r x)
(fun _ -> pts_to r y) | let write
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x y:Ghost.erased a)
(f:FStar.PCM.frame_preserving_upd p x y)
: act unit emp_inames
(pts_to r x)
(fun _ -> pts_to r y)
= fun #ictx -> mem_action_as_action _ _ _ _ (upd_gen ictx r x y f) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 66,
"end_line": 283,
"start_col": 0,
"start_line": 274
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p)
let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m
///////////////////////////////////////////////////////////////////
// Core operations on references
///////////////////////////////////////////////////////////////////
let ref (a:Type u#a) (p:pcm a) = ref a p
let ref_null (#a:Type u#a) (p:pcm a) = core_ref_null
let is_ref_null (#a:Type u#a) (#p:pcm a) (r:ref a p) = core_ref_is_null r
let pts_to = pts_to
let pts_to_not_null #a #p r v =
fun #ictx -> mem_action_as_action _ _ _ _ (pts_to_not_null_action ictx r v)
let alloc
(#a:Type u#1)
(#pcm:pcm a)
(x:a{compatible pcm x x /\ pcm.refine x})
: act (ref a pcm) emp_inames emp (fun r -> pts_to r x)
= fun #ictx ->
mem_action_as_action _ _ _ _
(alloc_action ictx x)
let read
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x:erased a)
(f:(v:a{compatible p x v}
-> GTot (y:a{compatible p y v /\
FStar.PCM.frame_compatible p x v y})))
: act (v:a{compatible p x v /\ p.refine v}) emp_inames
(pts_to r x)
(fun v -> pts_to r (f v))
= fun #ictx ->
mem_action_as_action _ _ _ _ (select_refine ictx r x f) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: PulseCore.Action.ref a p ->
x: FStar.Ghost.erased a ->
y: FStar.Ghost.erased a ->
f: FStar.PCM.frame_preserving_upd p (FStar.Ghost.reveal x) (FStar.Ghost.reveal y)
-> PulseCore.Action.act Prims.unit
PulseCore.Action.emp_inames
(PulseCore.Action.pts_to r (FStar.Ghost.reveal x))
(fun _ -> PulseCore.Action.pts_to r (FStar.Ghost.reveal y)) | Prims.Tot | [
"total"
] | [] | [
"FStar.PCM.pcm",
"PulseCore.Action.ref",
"FStar.Ghost.erased",
"FStar.PCM.frame_preserving_upd",
"FStar.Ghost.reveal",
"PulseCore.Action.inames_disj",
"PulseCore.Action.emp_inames",
"PulseCore.Action.mem_action_as_action",
"Prims.unit",
"PulseCore.Memory.pts_to",
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Memory.upd_gen",
"PulseCore.Action.action",
"PulseCore.Action.pts_to",
"PulseCore.Action.act"
] | [] | false | false | false | false | false | let write
(#a: Type)
(#p: pcm a)
(r: ref a p)
(x y: Ghost.erased a)
(f: FStar.PCM.frame_preserving_upd p x y)
: act unit emp_inames (pts_to r x) (fun _ -> pts_to r y) =
| fun #ictx -> mem_action_as_action _ _ _ _ (upd_gen ictx r x y f) | false |
PulseCore.Action.fst | PulseCore.Action.alloc | val alloc
(#a:Type u#1)
(#pcm:pcm a)
(x:a{compatible pcm x x /\ pcm.refine x})
: act (ref a pcm) emp_inames emp (fun r -> pts_to r x) | val alloc
(#a:Type u#1)
(#pcm:pcm a)
(x:a{compatible pcm x x /\ pcm.refine x})
: act (ref a pcm) emp_inames emp (fun r -> pts_to r x) | let alloc
(#a:Type u#1)
(#pcm:pcm a)
(x:a{compatible pcm x x /\ pcm.refine x})
: act (ref a pcm) emp_inames emp (fun r -> pts_to r x)
= fun #ictx ->
mem_action_as_action _ _ _ _
(alloc_action ictx x) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 29,
"end_line": 258,
"start_col": 0,
"start_line": 251
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p)
let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m
///////////////////////////////////////////////////////////////////
// Core operations on references
///////////////////////////////////////////////////////////////////
let ref (a:Type u#a) (p:pcm a) = ref a p
let ref_null (#a:Type u#a) (p:pcm a) = core_ref_null
let is_ref_null (#a:Type u#a) (#p:pcm a) (r:ref a p) = core_ref_is_null r
let pts_to = pts_to
let pts_to_not_null #a #p r v =
fun #ictx -> mem_action_as_action _ _ _ _ (pts_to_not_null_action ictx r v) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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{FStar.PCM.compatible pcm x x /\ Mkpcm?.refine pcm x}
-> PulseCore.Action.act (PulseCore.Action.ref a pcm)
PulseCore.Action.emp_inames
PulseCore.InstantiatedSemantics.emp
(fun r -> PulseCore.Action.pts_to r x) | Prims.Tot | [
"total"
] | [] | [
"FStar.PCM.pcm",
"Prims.l_and",
"FStar.PCM.compatible",
"FStar.PCM.__proj__Mkpcm__item__refine",
"PulseCore.Action.inames_disj",
"PulseCore.Action.emp_inames",
"PulseCore.Action.mem_action_as_action",
"PulseCore.Memory.ref",
"PulseCore.Memory.emp",
"PulseCore.Memory.pts_to",
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Memory.alloc_action",
"PulseCore.Action.action",
"PulseCore.Action.ref",
"PulseCore.InstantiatedSemantics.emp",
"PulseCore.Action.pts_to",
"PulseCore.Action.act"
] | [] | false | false | false | false | false | let alloc (#a: Type u#1) (#pcm: pcm a) (x: a{compatible pcm x x /\ pcm.refine x})
: act (ref a pcm) emp_inames emp (fun r -> pts_to r x) =
| fun #ictx -> mem_action_as_action _ _ _ _ (alloc_action ictx x) | false |
PulseCore.Action.fst | PulseCore.Action.pts_to_not_null | val pts_to_not_null (#a:Type) (#p:FStar.PCM.pcm a) (r:ref a p) (v:a)
: act (squash (not (is_ref_null r)))
emp_inames
(pts_to r v)
(fun _ -> pts_to r v) | val pts_to_not_null (#a:Type) (#p:FStar.PCM.pcm a) (r:ref a p) (v:a)
: act (squash (not (is_ref_null r)))
emp_inames
(pts_to r v)
(fun _ -> pts_to r v) | let pts_to_not_null #a #p r v =
fun #ictx -> mem_action_as_action _ _ _ _ (pts_to_not_null_action ictx r v) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 79,
"end_line": 249,
"start_col": 0,
"start_line": 248
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p)
let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m
///////////////////////////////////////////////////////////////////
// Core operations on references
///////////////////////////////////////////////////////////////////
let ref (a:Type u#a) (p:pcm a) = ref a p
let ref_null (#a:Type u#a) (p:pcm a) = core_ref_null
let is_ref_null (#a:Type u#a) (#p:pcm a) (r:ref a p) = core_ref_is_null r | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: PulseCore.Action.ref a p -> v: a
-> PulseCore.Action.act (Prims.squash (Prims.op_Negation (PulseCore.Action.is_ref_null r)))
PulseCore.Action.emp_inames
(PulseCore.Action.pts_to r v)
(fun _ -> PulseCore.Action.pts_to r v) | Prims.Tot | [
"total"
] | [] | [
"FStar.PCM.pcm",
"PulseCore.Action.ref",
"PulseCore.Action.inames_disj",
"PulseCore.Action.emp_inames",
"PulseCore.Action.mem_action_as_action",
"Prims.squash",
"Prims.b2t",
"Prims.op_Negation",
"PulseCore.Memory.is_null",
"FStar.Ghost.reveal",
"PulseCore.Memory.ref",
"FStar.Ghost.hide",
"PulseCore.Memory.pts_to",
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Memory.pts_to_not_null_action",
"PulseCore.Action.action",
"PulseCore.Action.is_ref_null",
"PulseCore.Action.pts_to"
] | [] | false | false | false | false | false | let pts_to_not_null #a #p r v =
| fun #ictx -> mem_action_as_action _ _ _ _ (pts_to_not_null_action ictx r v) | false |
PulseCore.Action.fst | PulseCore.Action.stt_of_action | val stt_of_action (#a: Type u#100) (#pre #post: _) (m: action a Set.empty pre post) : stt a pre post | val stt_of_action (#a: Type u#100) (#pre #post: _) (m: action a Set.empty pre post) : stt a pre post | let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 12,
"end_line": 66,
"start_col": 0,
"start_line": 58
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame') | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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 | m: PulseCore.Action.action a (FStar.Ghost.hide FStar.Set.empty) pre post
-> PulseCore.InstantiatedSemantics.stt a pre post | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Action.action",
"FStar.Ghost.hide",
"FStar.Set.set",
"PulseCore.Memory.iname",
"FStar.Set.empty",
"Prims.unit",
"PulseCore.Semantics.m",
"PulseCore.InstantiatedSemantics.state",
"FStar.FunctionalExtensionality.on_domain",
"PulseCore.Semantics.__proj__Mkstate__item__pred",
"FStar.FunctionalExtensionality.on_dom",
"PulseCore.Semantics.__proj__Mkaction__item__post",
"PulseCore.Semantics.act",
"PulseCore.Semantics.action",
"PulseCore.Semantics.Mkaction",
"PulseCore.Semantics.mst_sep",
"PulseCore.Memory.star",
"PulseCore.MonotonicStateMonad.weaken",
"PulseCore.Semantics.full_mem",
"PulseCore.Semantics.__proj__Mkstate__item__evolves",
"Prims.l_and",
"PulseCore.Memory.inames_ok",
"PulseCore.Semantics.__proj__Mkstate__item__interp",
"PulseCore.Semantics.__proj__Mkstate__item__star",
"PulseCore.Semantics.__proj__Mkstate__item__invariant",
"PulseCore.InstantiatedSemantics.state0",
"Prims.prop",
"Prims.l_True",
"PulseCore.InstantiatedSemantics.stt"
] | [] | false | false | false | false | false | let stt_of_action (#a: Type u#100) #pre #post (m: action a Set.empty pre post) : stt a pre post =
| let step (frame: slprop) : Sem.mst_sep state a (pre `star` frame) (fun x -> (post x) `star` frame) =
M.weaken (m frame)
in
let action:Sem.action state a = { pre = pre; post = F.on_dom _ post; step = step } in
let m:Sem.m a pre _ = Sem.act action in
fun _ -> m | false |
PulseCore.Action.fst | PulseCore.Action.witnessed | val witnessed (#a:Type u#1)
(#pcm:pcm a)
(r:ref a pcm)
(fact:property a)
: Type0 | val witnessed (#a:Type u#1)
(#pcm:pcm a)
(r:ref a pcm)
(fact:property a)
: Type0 | let witnessed = witnessed | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 25,
"end_line": 308,
"start_col": 0,
"start_line": 308
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p)
let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m
///////////////////////////////////////////////////////////////////
// Core operations on references
///////////////////////////////////////////////////////////////////
let ref (a:Type u#a) (p:pcm a) = ref a p
let ref_null (#a:Type u#a) (p:pcm a) = core_ref_null
let is_ref_null (#a:Type u#a) (#p:pcm a) (r:ref a p) = core_ref_is_null r
let pts_to = pts_to
let pts_to_not_null #a #p r v =
fun #ictx -> mem_action_as_action _ _ _ _ (pts_to_not_null_action ictx r v)
let alloc
(#a:Type u#1)
(#pcm:pcm a)
(x:a{compatible pcm x x /\ pcm.refine x})
: act (ref a pcm) emp_inames emp (fun r -> pts_to r x)
= fun #ictx ->
mem_action_as_action _ _ _ _
(alloc_action ictx x)
let read
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x:erased a)
(f:(v:a{compatible p x v}
-> GTot (y:a{compatible p y v /\
FStar.PCM.frame_compatible p x v y})))
: act (v:a{compatible p x v /\ p.refine v}) emp_inames
(pts_to r x)
(fun v -> pts_to r (f v))
= fun #ictx ->
mem_action_as_action _ _ _ _ (select_refine ictx r x f)
let write
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x y:Ghost.erased a)
(f:FStar.PCM.frame_preserving_upd p x y)
: act unit emp_inames
(pts_to r x)
(fun _ -> pts_to r y)
= fun #ictx -> mem_action_as_action _ _ _ _ (upd_gen ictx r x y f)
let share
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a{composable pcm v0 v1})
: act unit emp_inames
(pts_to r (v0 `op pcm` v1))
(fun _ -> pts_to r v0 `star` pts_to r v1)
= fun #ictx -> mem_action_as_action _ _ _ _ (split_action ictx r v0 v1)
let gather
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a)
: act (squash (composable pcm v0 v1))
emp_inames
(pts_to r v0 `star` pts_to r v1)
(fun _ -> pts_to r (op pcm v0 v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (gather_action ictx r v0 v1) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: PulseCore.Action.ref a pcm -> fact: PulseCore.Action.property a -> Type0 | Prims.Tot | [
"total"
] | [] | [
"PulseCore.Memory.witnessed"
] | [] | false | false | false | false | true | let witnessed =
| witnessed | false |
Steel.MonotonicHigherReference.fst | Steel.MonotonicHigherReference.rewrite_erased | val rewrite_erased (#a: _) (p: (erased a -> vprop)) (x: erased a) (y: a)
: Steel unit
(p x)
(fun _ -> p (Ghost.hide y))
(requires fun _ -> reveal x == y)
(ensures fun _ _ _ -> True) | val rewrite_erased (#a: _) (p: (erased a -> vprop)) (x: erased a) (y: a)
: Steel unit
(p x)
(fun _ -> p (Ghost.hide y))
(requires fun _ -> reveal x == y)
(ensures fun _ _ _ -> True) | let rewrite_erased #a (p:erased a -> vprop) (x:erased a) (y:a)
: Steel unit (p x) (fun _ -> p (Ghost.hide y))
(requires fun _ -> reveal x == y)
(ensures fun _ _ _ -> True)
= rewrite_slprop (p x) (p (Ghost.hide y)) (fun _ -> ()) | {
"file_name": "lib/steel/Steel.MonotonicHigherReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 57,
"end_line": 110,
"start_col": 0,
"start_line": 106
} | (*
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.MonotonicHigherReference
open FStar.Ghost
open FStar.PCM
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open Steel.PCMReference
open Steel.FractionalPermission
open Steel.Preorder
module Preorder = FStar.Preorder
module Q = Steel.Preorder
module M = Steel.Memory
module PR = Steel.PCMReference
open FStar.Real
#set-options "--ide_id_info_off"
let ref a p = M.ref (history a p) pcm_history
[@@__reduce__]
let pts_to_body #a #p (r:ref a p) (f:perm) (v:Ghost.erased a) (h:history a p) =
PR.pts_to r h `star`
pure (history_val h v f)
let pts_to' (#a:Type) (#p:Preorder.preorder a) (r:ref a p) (f:perm) (v:Ghost.erased a) =
h_exists (pts_to_body r f v)
let pts_to_sl r f v = hp_of (pts_to' r f v)
let intro_pure #a #p #f
(r:ref a p)
(v:a)
(h:history a p { history_val h v f })
: SteelT unit
(PR.pts_to r h)
(fun _ -> pts_to_body r f v h)
= rewrite_slprop (PR.pts_to r h) (pts_to_body _ _ _ _) (fun m ->
emp_unit (M.pts_to r h);
pure_star_interp (M.pts_to r h) (history_val h v f) m)
let intro_pure_full #a #p #f
(r:ref a p)
(v:a)
(h:history a p { history_val h v f })
: SteelT unit
(PR.pts_to r h)
(fun _ -> pts_to r f v)
= intro_pure #a #p #f r v h;
intro_exists h (pts_to_body r f v)
let alloc (#a:Type) (p:Preorder.preorder a) (v:a)
= let h = Current [v] full_perm in
assert (compatible pcm_history h h);
let x : ref a p = alloc h in
intro_pure_full x v h;
x
let extract_pure #a #uses #p #f
(r:ref a p)
(v:Ghost.erased a)
(h:Ghost.erased (history a p))
: SteelGhostT (_:unit{history_val h v f})
uses
(pts_to_body r f v h)
(fun _ -> pts_to_body r f v h)
= rewrite_slprop
(pts_to_body r f v h)
(PR.pts_to r h `star` pure (history_val h v f))
(fun _ -> ());
elim_pure (history_val h v f);
rewrite_slprop (PR.pts_to r h) (pts_to_body r f v h) (fun m ->
emp_unit (M.pts_to r h);
pure_star_interp (M.pts_to r h) (history_val h v f) m
)
let elim_pure #a #uses #p #f
(r:ref a p)
(v:Ghost.erased a)
(h:Ghost.erased (history a p))
: SteelGhostT (_:unit{history_val h v f})
uses
(pts_to_body r f v h)
(fun _ -> PR.pts_to r h)
= let _ = extract_pure r v h in
drop (pure (history_val h v f)) | {
"checked_file": "/",
"dependencies": [
"Steel.Preorder.fst.checked",
"Steel.PCMReference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.MonotonicHigherReference.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "PR"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "Steel.Preorder",
"short_module": "Q"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMReference",
"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.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"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": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"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 | p: (_: FStar.Ghost.erased a -> Steel.Effect.Common.vprop) -> x: FStar.Ghost.erased a -> y: a
-> Steel.Effect.Steel Prims.unit | Steel.Effect.Steel | [] | [] | [
"FStar.Ghost.erased",
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.rewrite_slprop",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.Memory.mem",
"Prims.unit",
"Steel.Effect.Common.rmem",
"Prims.eq2",
"FStar.Ghost.reveal",
"Prims.l_True"
] | [] | false | true | false | false | false | let rewrite_erased #a (p: (erased a -> vprop)) (x: erased a) (y: a)
: Steel unit
(p x)
(fun _ -> p (Ghost.hide y))
(requires fun _ -> reveal x == y)
(ensures fun _ _ _ -> True) =
| rewrite_slprop (p x) (p (Ghost.hide y)) (fun _ -> ()) | false |
PulseCore.Action.fst | PulseCore.Action.intro_pure | val intro_pure (p:prop) (pf:squash p)
: act unit emp_inames emp (fun _ -> pure p) | val intro_pure (p:prop) (pf:squash p)
: act unit emp_inames emp (fun _ -> pure p) | let intro_pure (p:prop) (pf:squash p)
: act unit emp_inames emp (fun _ -> pure p)
= fun #ictx -> mem_action_as_action _ _ _ _ (intro_pure #ictx p pf) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 67,
"end_line": 342,
"start_col": 0,
"start_line": 340
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p)
let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m
///////////////////////////////////////////////////////////////////
// Core operations on references
///////////////////////////////////////////////////////////////////
let ref (a:Type u#a) (p:pcm a) = ref a p
let ref_null (#a:Type u#a) (p:pcm a) = core_ref_null
let is_ref_null (#a:Type u#a) (#p:pcm a) (r:ref a p) = core_ref_is_null r
let pts_to = pts_to
let pts_to_not_null #a #p r v =
fun #ictx -> mem_action_as_action _ _ _ _ (pts_to_not_null_action ictx r v)
let alloc
(#a:Type u#1)
(#pcm:pcm a)
(x:a{compatible pcm x x /\ pcm.refine x})
: act (ref a pcm) emp_inames emp (fun r -> pts_to r x)
= fun #ictx ->
mem_action_as_action _ _ _ _
(alloc_action ictx x)
let read
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x:erased a)
(f:(v:a{compatible p x v}
-> GTot (y:a{compatible p y v /\
FStar.PCM.frame_compatible p x v y})))
: act (v:a{compatible p x v /\ p.refine v}) emp_inames
(pts_to r x)
(fun v -> pts_to r (f v))
= fun #ictx ->
mem_action_as_action _ _ _ _ (select_refine ictx r x f)
let write
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x y:Ghost.erased a)
(f:FStar.PCM.frame_preserving_upd p x y)
: act unit emp_inames
(pts_to r x)
(fun _ -> pts_to r y)
= fun #ictx -> mem_action_as_action _ _ _ _ (upd_gen ictx r x y f)
let share
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a{composable pcm v0 v1})
: act unit emp_inames
(pts_to r (v0 `op pcm` v1))
(fun _ -> pts_to r v0 `star` pts_to r v1)
= fun #ictx -> mem_action_as_action _ _ _ _ (split_action ictx r v0 v1)
let gather
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a)
: act (squash (composable pcm v0 v1))
emp_inames
(pts_to r v0 `star` pts_to r v1)
(fun _ -> pts_to r (op pcm v0 v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (gather_action ictx r v0 v1)
let witnessed = witnessed
let witness
(#a:Type)
(#pcm:pcm a)
(r:erased (ref a pcm))
(fact:stable_property pcm)
(v:Ghost.erased a)
(pf:squash (forall z. compatible pcm v z ==> fact z))
: act (witnessed r fact) emp_inames (pts_to r v) (fun _ -> pts_to r v)
= fun #ictx -> mem_action_as_action _ _ _ _ (witness ictx r fact v pf)
let recall
(#a:Type u#1)
(#pcm:pcm a)
(#fact:property a)
(r:erased (ref a pcm))
(v:Ghost.erased a)
(w:witnessed r fact)
: act (v1:Ghost.erased a{compatible pcm v v1})
emp_inames
(pts_to r v)
(fun v1 -> pts_to r v `star` pure (fact v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (recall ictx r v w)
///////////////////////////////////////////////////////////////////
// pure
///////////////////////////////////////////////////////////////////
let pure_true ()
= Mem.pure_true_emp ();
slprop_equiv_elim (pure True) emp;
coerce_eq () <| slprop_equiv_refl (pure True) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: Prims.prop -> pf: Prims.squash p
-> PulseCore.Action.act Prims.unit
PulseCore.Action.emp_inames
PulseCore.InstantiatedSemantics.emp
(fun _ -> PulseCore.InstantiatedSemantics.pure p) | Prims.Tot | [
"total"
] | [] | [
"Prims.prop",
"Prims.squash",
"PulseCore.Action.inames_disj",
"PulseCore.Action.emp_inames",
"PulseCore.Action.mem_action_as_action",
"Prims.unit",
"PulseCore.Memory.emp",
"PulseCore.Memory.pure",
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Memory.intro_pure",
"PulseCore.Action.action",
"PulseCore.InstantiatedSemantics.emp",
"PulseCore.InstantiatedSemantics.pure",
"PulseCore.Action.act"
] | [] | false | false | false | false | false | let intro_pure (p: prop) (pf: squash p) : act unit emp_inames emp (fun _ -> pure p) =
| fun #ictx -> mem_action_as_action _ _ _ _ (intro_pure #ictx p pf) | false |
PulseCore.Action.fst | PulseCore.Action.witness | val witness
(#a:Type)
(#pcm:pcm a)
(r:erased (ref a pcm))
(fact:stable_property pcm)
(v:Ghost.erased a)
(pf:squash (forall z. compatible pcm v z ==> fact z))
: act (witnessed r fact) emp_inames (pts_to r v) (fun _ -> pts_to r v) | val witness
(#a:Type)
(#pcm:pcm a)
(r:erased (ref a pcm))
(fact:stable_property pcm)
(v:Ghost.erased a)
(pf:squash (forall z. compatible pcm v z ==> fact z))
: act (witnessed r fact) emp_inames (pts_to r v) (fun _ -> pts_to r v) | let witness
(#a:Type)
(#pcm:pcm a)
(r:erased (ref a pcm))
(fact:stable_property pcm)
(v:Ghost.erased a)
(pf:squash (forall z. compatible pcm v z ==> fact z))
: act (witnessed r fact) emp_inames (pts_to r v) (fun _ -> pts_to r v)
= fun #ictx -> mem_action_as_action _ _ _ _ (witness ictx r fact v pf) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 70,
"end_line": 317,
"start_col": 0,
"start_line": 309
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p)
let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m
///////////////////////////////////////////////////////////////////
// Core operations on references
///////////////////////////////////////////////////////////////////
let ref (a:Type u#a) (p:pcm a) = ref a p
let ref_null (#a:Type u#a) (p:pcm a) = core_ref_null
let is_ref_null (#a:Type u#a) (#p:pcm a) (r:ref a p) = core_ref_is_null r
let pts_to = pts_to
let pts_to_not_null #a #p r v =
fun #ictx -> mem_action_as_action _ _ _ _ (pts_to_not_null_action ictx r v)
let alloc
(#a:Type u#1)
(#pcm:pcm a)
(x:a{compatible pcm x x /\ pcm.refine x})
: act (ref a pcm) emp_inames emp (fun r -> pts_to r x)
= fun #ictx ->
mem_action_as_action _ _ _ _
(alloc_action ictx x)
let read
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x:erased a)
(f:(v:a{compatible p x v}
-> GTot (y:a{compatible p y v /\
FStar.PCM.frame_compatible p x v y})))
: act (v:a{compatible p x v /\ p.refine v}) emp_inames
(pts_to r x)
(fun v -> pts_to r (f v))
= fun #ictx ->
mem_action_as_action _ _ _ _ (select_refine ictx r x f)
let write
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x y:Ghost.erased a)
(f:FStar.PCM.frame_preserving_upd p x y)
: act unit emp_inames
(pts_to r x)
(fun _ -> pts_to r y)
= fun #ictx -> mem_action_as_action _ _ _ _ (upd_gen ictx r x y f)
let share
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a{composable pcm v0 v1})
: act unit emp_inames
(pts_to r (v0 `op pcm` v1))
(fun _ -> pts_to r v0 `star` pts_to r v1)
= fun #ictx -> mem_action_as_action _ _ _ _ (split_action ictx r v0 v1)
let gather
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a)
: act (squash (composable pcm v0 v1))
emp_inames
(pts_to r v0 `star` pts_to r v1)
(fun _ -> pts_to r (op pcm v0 v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (gather_action ictx r v0 v1) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: FStar.Ghost.erased (PulseCore.Action.ref a pcm) ->
fact: PulseCore.Action.stable_property pcm ->
v: FStar.Ghost.erased a ->
pf: Prims.squash (forall (z: a). FStar.PCM.compatible pcm (FStar.Ghost.reveal v) z ==> fact z)
-> PulseCore.Action.act (PulseCore.Action.witnessed (FStar.Ghost.reveal r) fact)
PulseCore.Action.emp_inames
(PulseCore.Action.pts_to (FStar.Ghost.reveal r) (FStar.Ghost.reveal v))
(fun _ -> PulseCore.Action.pts_to (FStar.Ghost.reveal r) (FStar.Ghost.reveal v)) | Prims.Tot | [
"total"
] | [] | [
"FStar.PCM.pcm",
"FStar.Ghost.erased",
"PulseCore.Action.ref",
"PulseCore.Action.stable_property",
"Prims.squash",
"Prims.l_Forall",
"Prims.l_imp",
"FStar.PCM.compatible",
"FStar.Ghost.reveal",
"PulseCore.Action.inames_disj",
"PulseCore.Action.emp_inames",
"PulseCore.Action.mem_action_as_action",
"PulseCore.Memory.witnessed",
"PulseCore.Memory.ref",
"PulseCore.Memory.pts_to",
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Memory.witness",
"PulseCore.Action.action",
"PulseCore.Action.witnessed",
"PulseCore.Action.pts_to",
"PulseCore.Action.act"
] | [] | false | false | false | false | false | let witness
(#a: Type)
(#pcm: pcm a)
(r: erased (ref a pcm))
(fact: stable_property pcm)
(v: Ghost.erased a)
(pf: squash (forall z. compatible pcm v z ==> fact z))
: act (witnessed r fact) emp_inames (pts_to r v) (fun _ -> pts_to r v) =
| fun #ictx -> mem_action_as_action _ _ _ _ (witness ictx r fact v pf) | false |
PulseCore.Action.fst | PulseCore.Action.recall | val recall
(#a:Type u#1)
(#pcm:pcm a)
(#fact:property a)
(r:erased (ref a pcm))
(v:Ghost.erased a)
(w:witnessed r fact)
: act (v1:Ghost.erased a{compatible pcm v v1})
emp_inames
(pts_to r v)
(fun v1 -> pts_to r v ** pure (fact v1)) | val recall
(#a:Type u#1)
(#pcm:pcm a)
(#fact:property a)
(r:erased (ref a pcm))
(v:Ghost.erased a)
(w:witnessed r fact)
: act (v1:Ghost.erased a{compatible pcm v v1})
emp_inames
(pts_to r v)
(fun v1 -> pts_to r v ** pure (fact v1)) | let recall
(#a:Type u#1)
(#pcm:pcm a)
(#fact:property a)
(r:erased (ref a pcm))
(v:Ghost.erased a)
(w:witnessed r fact)
: act (v1:Ghost.erased a{compatible pcm v v1})
emp_inames
(pts_to r v)
(fun v1 -> pts_to r v `star` pure (fact v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (recall ictx r v w) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 63,
"end_line": 330,
"start_col": 0,
"start_line": 319
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p)
let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m
///////////////////////////////////////////////////////////////////
// Core operations on references
///////////////////////////////////////////////////////////////////
let ref (a:Type u#a) (p:pcm a) = ref a p
let ref_null (#a:Type u#a) (p:pcm a) = core_ref_null
let is_ref_null (#a:Type u#a) (#p:pcm a) (r:ref a p) = core_ref_is_null r
let pts_to = pts_to
let pts_to_not_null #a #p r v =
fun #ictx -> mem_action_as_action _ _ _ _ (pts_to_not_null_action ictx r v)
let alloc
(#a:Type u#1)
(#pcm:pcm a)
(x:a{compatible pcm x x /\ pcm.refine x})
: act (ref a pcm) emp_inames emp (fun r -> pts_to r x)
= fun #ictx ->
mem_action_as_action _ _ _ _
(alloc_action ictx x)
let read
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x:erased a)
(f:(v:a{compatible p x v}
-> GTot (y:a{compatible p y v /\
FStar.PCM.frame_compatible p x v y})))
: act (v:a{compatible p x v /\ p.refine v}) emp_inames
(pts_to r x)
(fun v -> pts_to r (f v))
= fun #ictx ->
mem_action_as_action _ _ _ _ (select_refine ictx r x f)
let write
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x y:Ghost.erased a)
(f:FStar.PCM.frame_preserving_upd p x y)
: act unit emp_inames
(pts_to r x)
(fun _ -> pts_to r y)
= fun #ictx -> mem_action_as_action _ _ _ _ (upd_gen ictx r x y f)
let share
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a{composable pcm v0 v1})
: act unit emp_inames
(pts_to r (v0 `op pcm` v1))
(fun _ -> pts_to r v0 `star` pts_to r v1)
= fun #ictx -> mem_action_as_action _ _ _ _ (split_action ictx r v0 v1)
let gather
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a)
: act (squash (composable pcm v0 v1))
emp_inames
(pts_to r v0 `star` pts_to r v1)
(fun _ -> pts_to r (op pcm v0 v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (gather_action ictx r v0 v1)
let witnessed = witnessed
let witness
(#a:Type)
(#pcm:pcm a)
(r:erased (ref a pcm))
(fact:stable_property pcm)
(v:Ghost.erased a)
(pf:squash (forall z. compatible pcm v z ==> fact z))
: act (witnessed r fact) emp_inames (pts_to r v) (fun _ -> pts_to r v)
= fun #ictx -> mem_action_as_action _ _ _ _ (witness ictx r fact v pf) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: FStar.Ghost.erased (PulseCore.Action.ref a pcm) ->
v: FStar.Ghost.erased a ->
w: PulseCore.Action.witnessed (FStar.Ghost.reveal r) fact
-> PulseCore.Action.act (v1:
FStar.Ghost.erased a
{FStar.PCM.compatible pcm (FStar.Ghost.reveal v) (FStar.Ghost.reveal v1)})
PulseCore.Action.emp_inames
(PulseCore.Action.pts_to (FStar.Ghost.reveal r) (FStar.Ghost.reveal v))
(fun v1 ->
PulseCore.Action.pts_to (FStar.Ghost.reveal r) (FStar.Ghost.reveal v) **
PulseCore.InstantiatedSemantics.pure (fact (FStar.Ghost.reveal v1))) | Prims.Tot | [
"total"
] | [] | [
"FStar.PCM.pcm",
"PulseCore.Action.property",
"FStar.Ghost.erased",
"PulseCore.Action.ref",
"PulseCore.Action.witnessed",
"FStar.Ghost.reveal",
"PulseCore.Action.inames_disj",
"PulseCore.Action.emp_inames",
"PulseCore.Action.mem_action_as_action",
"FStar.PCM.compatible",
"PulseCore.Memory.pts_to",
"PulseCore.Memory.ref",
"PulseCore.Memory.star",
"PulseCore.Memory.pure",
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Memory.recall",
"PulseCore.Action.action",
"PulseCore.Action.pts_to",
"PulseCore.InstantiatedSemantics.pure",
"PulseCore.Action.act",
"PulseCore.InstantiatedSemantics.op_Star_Star"
] | [] | false | false | false | false | false | let recall
(#a: Type u#1)
(#pcm: pcm a)
(#fact: property a)
(r: erased (ref a pcm))
(v: Ghost.erased a)
(w: witnessed r fact)
: act (v1: Ghost.erased a {compatible pcm v v1})
emp_inames
(pts_to r v)
(fun v1 -> (pts_to r v) `star` (pure (fact v1))) =
| fun #ictx -> mem_action_as_action _ _ _ _ (recall ictx r v w) | false |
PulseCore.Action.fst | PulseCore.Action.bind_action | val bind_action
(#a: Type u#a)
(#b: Type u#b)
(#except: inames)
(#pre1 #post1 #post2: _)
(f: action a except pre1 post1)
(g: (x: a -> action b except (post1 x) post2))
: action b except pre1 post2 | val bind_action
(#a: Type u#a)
(#b: Type u#b)
(#except: inames)
(#pre1 #post1 #post2: _)
(f: action a except pre1 post1)
(g: (x: a -> action b except (post1 x) post2))
: action b except pre1 post2 | let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame)) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 63,
"end_line": 48,
"start_col": 0,
"start_line": 40
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: PulseCore.Action.action a except pre1 post1 ->
g: (x: a -> PulseCore.Action.action b except (post1 x) post2)
-> PulseCore.Action.action b except pre1 post2 | Prims.Tot | [
"total"
] | [] | [
"PulseCore.Memory.inames",
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Action.action",
"PulseCore.MonotonicStateMonad.weaken",
"PulseCore.Semantics.full_mem",
"PulseCore.InstantiatedSemantics.state",
"PulseCore.Semantics.__proj__Mkstate__item__evolves",
"Prims.l_and",
"PulseCore.Memory.inames_ok",
"PulseCore.Semantics.__proj__Mkstate__item__interp",
"PulseCore.Semantics.__proj__Mkstate__item__star",
"PulseCore.Memory.star",
"PulseCore.Semantics.__proj__Mkstate__item__invariant",
"PulseCore.InstantiatedSemantics.state0",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.prop",
"Prims.l_Exists",
"PulseCore.MonotonicStateMonad.bind",
"PulseCore.MonotonicStateMonad.mst",
"PulseCore.Semantics.mst_sep_aux",
"PulseCore.Semantics.__proj__Mkstate__item__pred"
] | [] | false | false | false | false | false | let bind_action
(#a: Type u#a)
(#b: Type u#b)
(#except: inames)
(#pre1 #post1 #post2: _)
(f: action a except pre1 post1)
(g: (x: a -> action b except (post1 x) post2))
: action b except pre1 post2 =
| fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame)) | false |
StlcStrongDbParSubst.fst | StlcStrongDbParSubst.empty | val empty : env | val empty : env | let empty _ = None | {
"file_name": "examples/metatheory/StlcStrongDbParSubst.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 18,
"end_line": 113,
"start_col": 0,
"start_line": 113
} | (*
Copyright 2014-2015
Simon Forest - Inria and ENS Paris
Catalin Hritcu - Inria
Nikhil Swamy - 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 StlcStrongDbParSubst
open FStar.Constructive
open FStar.Classical
open FStar.FunctionalExtensionality
open FStar.StrongExcludedMiddle
(* Constructive-style progress and preservation proof for STLC with
strong reduction, using deBruijn indices and parallel substitution. *)
type typ =
| TArr : typ -> typ -> typ
| TUnit : typ
type var = nat
type exp =
| EVar : var -> exp
| EApp : exp -> exp -> exp
| ELam : typ -> exp -> exp
| EUnit : exp
(* Parallel substitution operation `subst` *)
(* The termination argument uses a lexicographic ordering composed of:
0) a bit saying whether the expression is a variable or not;
1) an _undecidable_ well-founded order on substitutions that
equates all renamings, equates all non-renamings, and makes
renamings strictly smaller than non-renamings; we write down a
non-constructive function is_renaming mapping substitutions
(infinite objects) to 0 (renaming) or 1 (non-renaming)
2) the structure of the expression e *)
type sub = var -> Tot exp
type renaming (s:sub) = (forall (x:var). EVar? (s x))
val is_renaming : s:sub -> GTot (n:int{ (renaming s ==> n=0) /\
(~(renaming s) ==> n=1)})
let is_renaming s = (if strong_excluded_middle (renaming s) then 0 else 1)
val sub_inc : var -> Tot exp
let sub_inc y = EVar (y+1)
val renaming_sub_inc : unit -> Lemma (renaming (sub_inc))
let renaming_sub_inc _ = ()
let is_var (e:exp) : int = if EVar? e then 0 else 1
val sub_elam: s:sub -> var -> Tot (e:exp{renaming s ==> EVar? e})
(decreases %[1;is_renaming s; 0; EVar 0])
val subst : s:sub -> e:exp -> Pure exp (requires True)
(ensures (fun e' -> (renaming s /\ EVar? e) ==> EVar? e'))
(decreases %[is_var e; is_renaming s; 1; e])
let rec subst s e =
match e with
| EVar x -> s x
| ELam t e1 -> ELam t (subst (sub_elam s) e1)
| EApp e1 e2 -> EApp (subst s e1) (subst s e2)
| EUnit -> EUnit
and sub_elam s y = if y=0 then EVar y
else subst sub_inc (s (y-1))
val sub_beta : exp -> Tot sub
let sub_beta v = fun y -> if y = 0 then v (* substitute *)
else (EVar (y-1)) (* shift -1 *)
(* Small-step operational semantics; strong / full-beta reduction is
non-deterministic, so necessarily as inductive relation *)
type step : exp -> exp -> Type =
| SBeta : t:typ ->
e1:exp ->
e2:exp ->
step (EApp (ELam t e1) e2) (subst (sub_beta e2) e1)
| SApp1 : #e1:exp ->
e2:exp ->
#e1':exp ->
$hst:step e1 e1' ->
step (EApp e1 e2) (EApp e1' e2)
| SApp2 : e1:exp ->
#e2:exp ->
#e2':exp ->
$hst:step e2 e2' ->
step (EApp e1 e2) (EApp e1 e2')
(* Type system; as inductive relation (not strictly necessary for STLC) *)
type env = var -> Tot (option typ) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Constructive.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "StlcStrongDbParSubst.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.StrongExcludedMiddle",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Constructive",
"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 | StlcStrongDbParSubst.env | Prims.Tot | [
"total"
] | [] | [
"StlcStrongDbParSubst.var",
"FStar.Pervasives.Native.None",
"StlcStrongDbParSubst.typ",
"FStar.Pervasives.Native.option"
] | [] | false | false | false | true | false | let empty _ =
| None | false |
StlcStrongDbParSubst.fst | StlcStrongDbParSubst.is_var | val is_var (e: exp) : int | val is_var (e: exp) : int | let is_var (e:exp) : int = if EVar? e then 0 else 1 | {
"file_name": "examples/metatheory/StlcStrongDbParSubst.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 51,
"end_line": 68,
"start_col": 0,
"start_line": 68
} | (*
Copyright 2014-2015
Simon Forest - Inria and ENS Paris
Catalin Hritcu - Inria
Nikhil Swamy - 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 StlcStrongDbParSubst
open FStar.Constructive
open FStar.Classical
open FStar.FunctionalExtensionality
open FStar.StrongExcludedMiddle
(* Constructive-style progress and preservation proof for STLC with
strong reduction, using deBruijn indices and parallel substitution. *)
type typ =
| TArr : typ -> typ -> typ
| TUnit : typ
type var = nat
type exp =
| EVar : var -> exp
| EApp : exp -> exp -> exp
| ELam : typ -> exp -> exp
| EUnit : exp
(* Parallel substitution operation `subst` *)
(* The termination argument uses a lexicographic ordering composed of:
0) a bit saying whether the expression is a variable or not;
1) an _undecidable_ well-founded order on substitutions that
equates all renamings, equates all non-renamings, and makes
renamings strictly smaller than non-renamings; we write down a
non-constructive function is_renaming mapping substitutions
(infinite objects) to 0 (renaming) or 1 (non-renaming)
2) the structure of the expression e *)
type sub = var -> Tot exp
type renaming (s:sub) = (forall (x:var). EVar? (s x))
val is_renaming : s:sub -> GTot (n:int{ (renaming s ==> n=0) /\
(~(renaming s) ==> n=1)})
let is_renaming s = (if strong_excluded_middle (renaming s) then 0 else 1)
val sub_inc : var -> Tot exp
let sub_inc y = EVar (y+1)
val renaming_sub_inc : unit -> Lemma (renaming (sub_inc))
let renaming_sub_inc _ = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Constructive.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "StlcStrongDbParSubst.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.StrongExcludedMiddle",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Constructive",
"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 | e: StlcStrongDbParSubst.exp -> Prims.int | Prims.Tot | [
"total"
] | [] | [
"StlcStrongDbParSubst.exp",
"StlcStrongDbParSubst.uu___is_EVar",
"Prims.bool",
"Prims.int"
] | [] | false | false | false | true | false | let is_var (e: exp) : int =
| if EVar? e then 0 else 1 | false |
PulseCore.Action.fst | PulseCore.Action.thunk | val thunk : p: PulseCore.InstantiatedSemantics.slprop -> _: Prims.unit -> PulseCore.InstantiatedSemantics.slprop | let thunk (p:slprop) = fun (_:unit) -> p | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 40,
"end_line": 358,
"start_col": 0,
"start_line": 358
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p)
let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m
///////////////////////////////////////////////////////////////////
// Core operations on references
///////////////////////////////////////////////////////////////////
let ref (a:Type u#a) (p:pcm a) = ref a p
let ref_null (#a:Type u#a) (p:pcm a) = core_ref_null
let is_ref_null (#a:Type u#a) (#p:pcm a) (r:ref a p) = core_ref_is_null r
let pts_to = pts_to
let pts_to_not_null #a #p r v =
fun #ictx -> mem_action_as_action _ _ _ _ (pts_to_not_null_action ictx r v)
let alloc
(#a:Type u#1)
(#pcm:pcm a)
(x:a{compatible pcm x x /\ pcm.refine x})
: act (ref a pcm) emp_inames emp (fun r -> pts_to r x)
= fun #ictx ->
mem_action_as_action _ _ _ _
(alloc_action ictx x)
let read
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x:erased a)
(f:(v:a{compatible p x v}
-> GTot (y:a{compatible p y v /\
FStar.PCM.frame_compatible p x v y})))
: act (v:a{compatible p x v /\ p.refine v}) emp_inames
(pts_to r x)
(fun v -> pts_to r (f v))
= fun #ictx ->
mem_action_as_action _ _ _ _ (select_refine ictx r x f)
let write
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x y:Ghost.erased a)
(f:FStar.PCM.frame_preserving_upd p x y)
: act unit emp_inames
(pts_to r x)
(fun _ -> pts_to r y)
= fun #ictx -> mem_action_as_action _ _ _ _ (upd_gen ictx r x y f)
let share
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a{composable pcm v0 v1})
: act unit emp_inames
(pts_to r (v0 `op pcm` v1))
(fun _ -> pts_to r v0 `star` pts_to r v1)
= fun #ictx -> mem_action_as_action _ _ _ _ (split_action ictx r v0 v1)
let gather
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a)
: act (squash (composable pcm v0 v1))
emp_inames
(pts_to r v0 `star` pts_to r v1)
(fun _ -> pts_to r (op pcm v0 v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (gather_action ictx r v0 v1)
let witnessed = witnessed
let witness
(#a:Type)
(#pcm:pcm a)
(r:erased (ref a pcm))
(fact:stable_property pcm)
(v:Ghost.erased a)
(pf:squash (forall z. compatible pcm v z ==> fact z))
: act (witnessed r fact) emp_inames (pts_to r v) (fun _ -> pts_to r v)
= fun #ictx -> mem_action_as_action _ _ _ _ (witness ictx r fact v pf)
let recall
(#a:Type u#1)
(#pcm:pcm a)
(#fact:property a)
(r:erased (ref a pcm))
(v:Ghost.erased a)
(w:witnessed r fact)
: act (v1:Ghost.erased a{compatible pcm v v1})
emp_inames
(pts_to r v)
(fun v1 -> pts_to r v `star` pure (fact v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (recall ictx r v w)
///////////////////////////////////////////////////////////////////
// pure
///////////////////////////////////////////////////////////////////
let pure_true ()
= Mem.pure_true_emp ();
slprop_equiv_elim (pure True) emp;
coerce_eq () <| slprop_equiv_refl (pure True)
let intro_pure (p:prop) (pf:squash p)
: act unit emp_inames emp (fun _ -> pure p)
= fun #ictx -> mem_action_as_action _ _ _ _ (intro_pure #ictx p pf)
let elim_pure (p:prop)
: act (squash p) emp_inames (pure p) (fun _ -> emp)
= fun #ictx -> mem_action_as_action _ _ _ _ (elim_pure #ictx p)
///////////////////////////////////////////////////////////////////
// exists*
///////////////////////////////////////////////////////////////////
module F = FStar.FunctionalExtensionality
let exists_equiv (#a:_) (#p:a -> slprop)
: squash (op_exists_Star p == (exists* x. p x))
= let pf = I.slprop_equiv_exists p (fun x -> p x) () in
let pf = FStar.Squash.return_squash pf in
I.slprop_equiv_elim (op_exists_Star p) (exists* x. p x) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: PulseCore.InstantiatedSemantics.slprop -> _: Prims.unit -> PulseCore.InstantiatedSemantics.slprop | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"Prims.unit"
] | [] | false | false | false | true | false | let thunk (p: slprop) =
| fun (_: unit) -> p | false |
|
PulseCore.Action.fst | PulseCore.Action.intro_exists' | val intro_exists' (#a: Type u#a) (p: (a -> slprop)) (x: erased a)
: act unit emp_inames (p x) (thunk (op_exists_Star p)) | val intro_exists' (#a: Type u#a) (p: (a -> slprop)) (x: erased a)
: act unit emp_inames (p x) (thunk (op_exists_Star p)) | let intro_exists' (#a:Type u#a) (p:a -> slprop) (x:erased a)
: act unit emp_inames (p x) (thunk (op_exists_Star p))
= fun #ictx -> mem_action_as_action _ _ _ _ (intro_exists #ictx (F.on_dom a p) x) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 81,
"end_line": 362,
"start_col": 0,
"start_line": 360
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p)
let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m
///////////////////////////////////////////////////////////////////
// Core operations on references
///////////////////////////////////////////////////////////////////
let ref (a:Type u#a) (p:pcm a) = ref a p
let ref_null (#a:Type u#a) (p:pcm a) = core_ref_null
let is_ref_null (#a:Type u#a) (#p:pcm a) (r:ref a p) = core_ref_is_null r
let pts_to = pts_to
let pts_to_not_null #a #p r v =
fun #ictx -> mem_action_as_action _ _ _ _ (pts_to_not_null_action ictx r v)
let alloc
(#a:Type u#1)
(#pcm:pcm a)
(x:a{compatible pcm x x /\ pcm.refine x})
: act (ref a pcm) emp_inames emp (fun r -> pts_to r x)
= fun #ictx ->
mem_action_as_action _ _ _ _
(alloc_action ictx x)
let read
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x:erased a)
(f:(v:a{compatible p x v}
-> GTot (y:a{compatible p y v /\
FStar.PCM.frame_compatible p x v y})))
: act (v:a{compatible p x v /\ p.refine v}) emp_inames
(pts_to r x)
(fun v -> pts_to r (f v))
= fun #ictx ->
mem_action_as_action _ _ _ _ (select_refine ictx r x f)
let write
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x y:Ghost.erased a)
(f:FStar.PCM.frame_preserving_upd p x y)
: act unit emp_inames
(pts_to r x)
(fun _ -> pts_to r y)
= fun #ictx -> mem_action_as_action _ _ _ _ (upd_gen ictx r x y f)
let share
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a{composable pcm v0 v1})
: act unit emp_inames
(pts_to r (v0 `op pcm` v1))
(fun _ -> pts_to r v0 `star` pts_to r v1)
= fun #ictx -> mem_action_as_action _ _ _ _ (split_action ictx r v0 v1)
let gather
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a)
: act (squash (composable pcm v0 v1))
emp_inames
(pts_to r v0 `star` pts_to r v1)
(fun _ -> pts_to r (op pcm v0 v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (gather_action ictx r v0 v1)
let witnessed = witnessed
let witness
(#a:Type)
(#pcm:pcm a)
(r:erased (ref a pcm))
(fact:stable_property pcm)
(v:Ghost.erased a)
(pf:squash (forall z. compatible pcm v z ==> fact z))
: act (witnessed r fact) emp_inames (pts_to r v) (fun _ -> pts_to r v)
= fun #ictx -> mem_action_as_action _ _ _ _ (witness ictx r fact v pf)
let recall
(#a:Type u#1)
(#pcm:pcm a)
(#fact:property a)
(r:erased (ref a pcm))
(v:Ghost.erased a)
(w:witnessed r fact)
: act (v1:Ghost.erased a{compatible pcm v v1})
emp_inames
(pts_to r v)
(fun v1 -> pts_to r v `star` pure (fact v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (recall ictx r v w)
///////////////////////////////////////////////////////////////////
// pure
///////////////////////////////////////////////////////////////////
let pure_true ()
= Mem.pure_true_emp ();
slprop_equiv_elim (pure True) emp;
coerce_eq () <| slprop_equiv_refl (pure True)
let intro_pure (p:prop) (pf:squash p)
: act unit emp_inames emp (fun _ -> pure p)
= fun #ictx -> mem_action_as_action _ _ _ _ (intro_pure #ictx p pf)
let elim_pure (p:prop)
: act (squash p) emp_inames (pure p) (fun _ -> emp)
= fun #ictx -> mem_action_as_action _ _ _ _ (elim_pure #ictx p)
///////////////////////////////////////////////////////////////////
// exists*
///////////////////////////////////////////////////////////////////
module F = FStar.FunctionalExtensionality
let exists_equiv (#a:_) (#p:a -> slprop)
: squash (op_exists_Star p == (exists* x. p x))
= let pf = I.slprop_equiv_exists p (fun x -> p x) () in
let pf = FStar.Squash.return_squash pf in
I.slprop_equiv_elim (op_exists_Star p) (exists* x. p x)
let thunk (p:slprop) = fun (_:unit) -> p | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: (_: a -> PulseCore.InstantiatedSemantics.slprop) -> x: FStar.Ghost.erased a
-> PulseCore.Action.act Prims.unit
PulseCore.Action.emp_inames
(p (FStar.Ghost.reveal x))
(PulseCore.Action.thunk (exists . p)) | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"FStar.Ghost.erased",
"PulseCore.Action.inames_disj",
"PulseCore.Action.emp_inames",
"PulseCore.Action.mem_action_as_action",
"Prims.unit",
"FStar.Ghost.reveal",
"PulseCore.Memory.h_exists",
"FStar.FunctionalExtensionality.on_dom",
"PulseCore.Memory.slprop",
"PulseCore.Memory.intro_exists",
"PulseCore.Action.action",
"PulseCore.Action.thunk",
"PulseCore.InstantiatedSemantics.op_exists_Star",
"PulseCore.Action.act"
] | [] | false | false | false | false | false | let intro_exists' (#a: Type u#a) (p: (a -> slprop)) (x: erased a)
: act unit emp_inames (p x) (thunk (op_exists_Star p)) =
| fun #ictx -> mem_action_as_action _ _ _ _ (intro_exists #ictx (F.on_dom a p) x) | false |
PulseCore.Action.fst | PulseCore.Action.stt_of_action0 | val stt_of_action0 (#a: Type u#0) (#pre #post: _) (m: action a Set.empty pre post) : stt a pre post | val stt_of_action0 (#a: Type u#0) (#pre #post: _) (m: action a Set.empty pre post) : stt a pre post | let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 31,
"end_line": 75,
"start_col": 0,
"start_line": 68
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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 | m: PulseCore.Action.action a (FStar.Ghost.hide FStar.Set.empty) pre post
-> PulseCore.InstantiatedSemantics.stt a pre post | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Action.action",
"FStar.Ghost.hide",
"FStar.Set.set",
"PulseCore.Memory.iname",
"FStar.Set.empty",
"Prims.unit",
"PulseCore.Semantics.act_as_m0",
"PulseCore.InstantiatedSemantics.state",
"PulseCore.Semantics.m",
"PulseCore.Semantics.__proj__Mkaction__item__pre",
"PulseCore.Semantics.__proj__Mkaction__item__post",
"FStar.FunctionalExtensionality.on_dom",
"PulseCore.Semantics.__proj__Mkstate__item__pred",
"PulseCore.Semantics.action",
"PulseCore.Semantics.Mkaction",
"PulseCore.Semantics.mst_sep",
"PulseCore.Memory.star",
"PulseCore.MonotonicStateMonad.weaken",
"PulseCore.Semantics.full_mem",
"PulseCore.Semantics.__proj__Mkstate__item__evolves",
"Prims.l_and",
"PulseCore.Memory.inames_ok",
"PulseCore.Semantics.__proj__Mkstate__item__interp",
"PulseCore.Semantics.__proj__Mkstate__item__star",
"PulseCore.Semantics.__proj__Mkstate__item__invariant",
"PulseCore.InstantiatedSemantics.state0",
"Prims.prop",
"Prims.l_True",
"PulseCore.InstantiatedSemantics.stt"
] | [] | false | false | false | false | false | let stt_of_action0 (#a: Type u#0) #pre #post (m: action a Set.empty pre post) : stt a pre post =
| let step (frame: slprop) : Sem.mst_sep state a (pre `star` frame) (fun x -> (post x) `star` frame) =
M.weaken (m frame)
in
let action:Sem.action state a = { pre = pre; post = F.on_dom _ post; step = step } in
fun _ -> Sem.act_as_m0 action | false |
Steel.MonotonicHigherReference.fst | Steel.MonotonicHigherReference.witness_thunk | val witness_thunk:
#inames: _ ->
#a: Type ->
#pcm: FStar.PCM.pcm a ->
r: Ghost.erased (M.ref a pcm) ->
fact: M.stable_property pcm ->
v: Ghost.erased a ->
squash (fact_valid_compat #_ #pcm fact v) ->
unit
-> SteelAtomicUT (M.witnessed r fact) inames (PR.pts_to r v) (fun _ -> PR.pts_to r v) | val witness_thunk:
#inames: _ ->
#a: Type ->
#pcm: FStar.PCM.pcm a ->
r: Ghost.erased (M.ref a pcm) ->
fact: M.stable_property pcm ->
v: Ghost.erased a ->
squash (fact_valid_compat #_ #pcm fact v) ->
unit
-> SteelAtomicUT (M.witnessed r fact) inames (PR.pts_to r v) (fun _ -> PR.pts_to r v) | let witness_thunk (#inames: _) (#a:Type) (#pcm:FStar.PCM.pcm a)
(r:Ghost.erased (M.ref a pcm))
(fact:M.stable_property pcm)
(v:Ghost.erased a)
(_:squash (fact_valid_compat #_ #pcm fact v))
(_:unit)
: SteelAtomicUT (M.witnessed r fact) inames (PR.pts_to r v)
(fun _ -> PR.pts_to r v)
= witness r fact v () | {
"file_name": "lib/steel/Steel.MonotonicHigherReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 23,
"end_line": 172,
"start_col": 0,
"start_line": 164
} | (*
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.MonotonicHigherReference
open FStar.Ghost
open FStar.PCM
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open Steel.PCMReference
open Steel.FractionalPermission
open Steel.Preorder
module Preorder = FStar.Preorder
module Q = Steel.Preorder
module M = Steel.Memory
module PR = Steel.PCMReference
open FStar.Real
#set-options "--ide_id_info_off"
let ref a p = M.ref (history a p) pcm_history
[@@__reduce__]
let pts_to_body #a #p (r:ref a p) (f:perm) (v:Ghost.erased a) (h:history a p) =
PR.pts_to r h `star`
pure (history_val h v f)
let pts_to' (#a:Type) (#p:Preorder.preorder a) (r:ref a p) (f:perm) (v:Ghost.erased a) =
h_exists (pts_to_body r f v)
let pts_to_sl r f v = hp_of (pts_to' r f v)
let intro_pure #a #p #f
(r:ref a p)
(v:a)
(h:history a p { history_val h v f })
: SteelT unit
(PR.pts_to r h)
(fun _ -> pts_to_body r f v h)
= rewrite_slprop (PR.pts_to r h) (pts_to_body _ _ _ _) (fun m ->
emp_unit (M.pts_to r h);
pure_star_interp (M.pts_to r h) (history_val h v f) m)
let intro_pure_full #a #p #f
(r:ref a p)
(v:a)
(h:history a p { history_val h v f })
: SteelT unit
(PR.pts_to r h)
(fun _ -> pts_to r f v)
= intro_pure #a #p #f r v h;
intro_exists h (pts_to_body r f v)
let alloc (#a:Type) (p:Preorder.preorder a) (v:a)
= let h = Current [v] full_perm in
assert (compatible pcm_history h h);
let x : ref a p = alloc h in
intro_pure_full x v h;
x
let extract_pure #a #uses #p #f
(r:ref a p)
(v:Ghost.erased a)
(h:Ghost.erased (history a p))
: SteelGhostT (_:unit{history_val h v f})
uses
(pts_to_body r f v h)
(fun _ -> pts_to_body r f v h)
= rewrite_slprop
(pts_to_body r f v h)
(PR.pts_to r h `star` pure (history_val h v f))
(fun _ -> ());
elim_pure (history_val h v f);
rewrite_slprop (PR.pts_to r h) (pts_to_body r f v h) (fun m ->
emp_unit (M.pts_to r h);
pure_star_interp (M.pts_to r h) (history_val h v f) m
)
let elim_pure #a #uses #p #f
(r:ref a p)
(v:Ghost.erased a)
(h:Ghost.erased (history a p))
: SteelGhostT (_:unit{history_val h v f})
uses
(pts_to_body r f v h)
(fun _ -> PR.pts_to r h)
= let _ = extract_pure r v h in
drop (pure (history_val h v f))
let rewrite_erased #a (p:erased a -> vprop) (x:erased a) (y:a)
: Steel unit (p x) (fun _ -> p (Ghost.hide y))
(requires fun _ -> reveal x == y)
(ensures fun _ _ _ -> True)
= rewrite_slprop (p x) (p (Ghost.hide y)) (fun _ -> ())
let rewrite_reveal_hide #a (x:a) (p:a -> vprop) ()
: SteelT unit (p (Ghost.reveal (Ghost.hide x))) (fun _ -> p x)
= rewrite_slprop (p (Ghost.reveal (Ghost.hide x))) (p x) (fun _ -> ())
let read_refine (#a:Type) (#q:perm) (#p:Preorder.preorder a) (#f:a -> vprop)
(r:ref a p)
: SteelT a (h_exists (fun (v:a) -> pts_to r q v `star` f v))
(fun v -> pts_to r q v `star` f v)
= let v = witness_exists () in
rewrite_slprop (pts_to r q (Ghost.hide (Ghost.reveal v)) `star` f v) (h_exists (pts_to_body r q v) `star` f v) (fun _ -> ());
let h = witness_exists () in
let _ = elim_pure r v h in
let hv = read r h in
let _:squash (compatible pcm_history h hv) = () in
rewrite_slprop (PR.pts_to r h) (pts_to_body r q v h) (fun m ->
emp_unit (M.pts_to r h);
pure_star_interp (M.pts_to r h) (history_val h v q) m);
intro_exists_erased h (pts_to_body r q v);
rewrite_erased (fun v -> (pts_to r q v `star` f v)) v (hval_tot hv);
let v = hval_tot hv in
rewrite_slprop
(pts_to r q (hval_tot hv) `star` f (Ghost.reveal (Ghost.hide (hval_tot hv))))
(pts_to r q v `star` f v)
(fun _ -> ());
return v
let write (#a:Type) (#p:Preorder.preorder a) (#v:erased a)
(r:ref a p) (x:a)
: Steel unit (pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires fun _ -> p v x /\ True)
(ensures fun _ _ _ -> True)
= let h_old_e = witness_exists #_ #_ #(pts_to_body r full_perm v) () in
let _ = elim_pure r v h_old_e in
let h_old = read r h_old_e in
let h: history a p = extend_history' h_old x in
write r h_old_e h;
intro_pure_full r x h
let witnessed #a #p r fact =
M.witnessed r (lift_fact fact)
let get_squash (#p:prop) (_:unit{p}) : squash p = () | {
"checked_file": "/",
"dependencies": [
"Steel.Preorder.fst.checked",
"Steel.PCMReference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.MonotonicHigherReference.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "PR"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "Steel.Preorder",
"short_module": "Q"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMReference",
"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.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"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": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"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 |
r: FStar.Ghost.erased (Steel.Memory.ref a pcm) ->
fact: Steel.Memory.stable_property pcm ->
v: FStar.Ghost.erased a ->
_: Prims.squash (Steel.Preorder.fact_valid_compat fact (FStar.Ghost.reveal v)) ->
_: Prims.unit
-> Steel.Effect.Atomic.SteelAtomicUT (Steel.Memory.witnessed (FStar.Ghost.reveal r) fact) | Steel.Effect.Atomic.SteelAtomicUT | [] | [] | [
"Steel.Memory.inames",
"FStar.PCM.pcm",
"FStar.Ghost.erased",
"Steel.Memory.ref",
"Steel.Memory.stable_property",
"Prims.squash",
"Steel.Preorder.fact_valid_compat",
"FStar.Ghost.reveal",
"Prims.unit",
"Steel.PCMReference.witness",
"Steel.Memory.witnessed",
"Steel.PCMReference.pts_to",
"Steel.Effect.Common.vprop"
] | [] | false | true | false | false | false | let witness_thunk
(#inames: _)
(#a: Type)
(#pcm: FStar.PCM.pcm a)
(r: Ghost.erased (M.ref a pcm))
(fact: M.stable_property pcm)
(v: Ghost.erased a)
(_: squash (fact_valid_compat #_ #pcm fact v))
(_: unit)
: SteelAtomicUT (M.witnessed r fact) inames (PR.pts_to r v) (fun _ -> PR.pts_to r v) =
| witness r fact v () | false |
PulseCore.Action.fst | PulseCore.Action.elim_pure | val elim_pure (p:prop)
: act (squash p) emp_inames (pure p) (fun _ -> emp) | val elim_pure (p:prop)
: act (squash p) emp_inames (pure p) (fun _ -> emp) | let elim_pure (p:prop)
: act (squash p) emp_inames (pure p) (fun _ -> emp)
= fun #ictx -> mem_action_as_action _ _ _ _ (elim_pure #ictx p) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 63,
"end_line": 346,
"start_col": 0,
"start_line": 344
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p)
let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m
///////////////////////////////////////////////////////////////////
// Core operations on references
///////////////////////////////////////////////////////////////////
let ref (a:Type u#a) (p:pcm a) = ref a p
let ref_null (#a:Type u#a) (p:pcm a) = core_ref_null
let is_ref_null (#a:Type u#a) (#p:pcm a) (r:ref a p) = core_ref_is_null r
let pts_to = pts_to
let pts_to_not_null #a #p r v =
fun #ictx -> mem_action_as_action _ _ _ _ (pts_to_not_null_action ictx r v)
let alloc
(#a:Type u#1)
(#pcm:pcm a)
(x:a{compatible pcm x x /\ pcm.refine x})
: act (ref a pcm) emp_inames emp (fun r -> pts_to r x)
= fun #ictx ->
mem_action_as_action _ _ _ _
(alloc_action ictx x)
let read
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x:erased a)
(f:(v:a{compatible p x v}
-> GTot (y:a{compatible p y v /\
FStar.PCM.frame_compatible p x v y})))
: act (v:a{compatible p x v /\ p.refine v}) emp_inames
(pts_to r x)
(fun v -> pts_to r (f v))
= fun #ictx ->
mem_action_as_action _ _ _ _ (select_refine ictx r x f)
let write
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x y:Ghost.erased a)
(f:FStar.PCM.frame_preserving_upd p x y)
: act unit emp_inames
(pts_to r x)
(fun _ -> pts_to r y)
= fun #ictx -> mem_action_as_action _ _ _ _ (upd_gen ictx r x y f)
let share
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a{composable pcm v0 v1})
: act unit emp_inames
(pts_to r (v0 `op pcm` v1))
(fun _ -> pts_to r v0 `star` pts_to r v1)
= fun #ictx -> mem_action_as_action _ _ _ _ (split_action ictx r v0 v1)
let gather
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a)
: act (squash (composable pcm v0 v1))
emp_inames
(pts_to r v0 `star` pts_to r v1)
(fun _ -> pts_to r (op pcm v0 v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (gather_action ictx r v0 v1)
let witnessed = witnessed
let witness
(#a:Type)
(#pcm:pcm a)
(r:erased (ref a pcm))
(fact:stable_property pcm)
(v:Ghost.erased a)
(pf:squash (forall z. compatible pcm v z ==> fact z))
: act (witnessed r fact) emp_inames (pts_to r v) (fun _ -> pts_to r v)
= fun #ictx -> mem_action_as_action _ _ _ _ (witness ictx r fact v pf)
let recall
(#a:Type u#1)
(#pcm:pcm a)
(#fact:property a)
(r:erased (ref a pcm))
(v:Ghost.erased a)
(w:witnessed r fact)
: act (v1:Ghost.erased a{compatible pcm v v1})
emp_inames
(pts_to r v)
(fun v1 -> pts_to r v `star` pure (fact v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (recall ictx r v w)
///////////////////////////////////////////////////////////////////
// pure
///////////////////////////////////////////////////////////////////
let pure_true ()
= Mem.pure_true_emp ();
slprop_equiv_elim (pure True) emp;
coerce_eq () <| slprop_equiv_refl (pure True)
let intro_pure (p:prop) (pf:squash p)
: act unit emp_inames emp (fun _ -> pure p)
= fun #ictx -> mem_action_as_action _ _ _ _ (intro_pure #ictx p pf) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: Prims.prop
-> PulseCore.Action.act (Prims.squash p)
PulseCore.Action.emp_inames
(PulseCore.InstantiatedSemantics.pure p)
(fun _ -> PulseCore.InstantiatedSemantics.emp) | Prims.Tot | [
"total"
] | [] | [
"Prims.prop",
"PulseCore.Action.inames_disj",
"PulseCore.Action.emp_inames",
"PulseCore.Action.mem_action_as_action",
"Prims.unit",
"PulseCore.Memory.pure",
"PulseCore.Memory.emp",
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Memory.elim_pure",
"PulseCore.Action.action",
"Prims.squash",
"PulseCore.InstantiatedSemantics.pure",
"PulseCore.InstantiatedSemantics.emp",
"PulseCore.Action.act"
] | [] | false | false | false | false | false | let elim_pure (p: prop) : act (squash p) emp_inames (pure p) (fun _ -> emp) =
| fun #ictx -> mem_action_as_action _ _ _ _ (elim_pure #ictx p) | false |
PulseCore.Action.fst | PulseCore.Action.intro_exists | val intro_exists (#a:Type u#a) (p:a -> slprop) (x:erased a)
: act unit emp_inames (p x) (fun _ -> exists* x. p x) | val intro_exists (#a:Type u#a) (p:a -> slprop) (x:erased a)
: act unit emp_inames (p x) (fun _ -> exists* x. p x) | let intro_exists (#a:Type u#a) (p:a -> slprop) (x:erased a)
: act unit emp_inames (p x) (fun _ -> exists* x. p x)
= intro_exists'' p x | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 20,
"end_line": 370,
"start_col": 0,
"start_line": 368
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p)
let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m
///////////////////////////////////////////////////////////////////
// Core operations on references
///////////////////////////////////////////////////////////////////
let ref (a:Type u#a) (p:pcm a) = ref a p
let ref_null (#a:Type u#a) (p:pcm a) = core_ref_null
let is_ref_null (#a:Type u#a) (#p:pcm a) (r:ref a p) = core_ref_is_null r
let pts_to = pts_to
let pts_to_not_null #a #p r v =
fun #ictx -> mem_action_as_action _ _ _ _ (pts_to_not_null_action ictx r v)
let alloc
(#a:Type u#1)
(#pcm:pcm a)
(x:a{compatible pcm x x /\ pcm.refine x})
: act (ref a pcm) emp_inames emp (fun r -> pts_to r x)
= fun #ictx ->
mem_action_as_action _ _ _ _
(alloc_action ictx x)
let read
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x:erased a)
(f:(v:a{compatible p x v}
-> GTot (y:a{compatible p y v /\
FStar.PCM.frame_compatible p x v y})))
: act (v:a{compatible p x v /\ p.refine v}) emp_inames
(pts_to r x)
(fun v -> pts_to r (f v))
= fun #ictx ->
mem_action_as_action _ _ _ _ (select_refine ictx r x f)
let write
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x y:Ghost.erased a)
(f:FStar.PCM.frame_preserving_upd p x y)
: act unit emp_inames
(pts_to r x)
(fun _ -> pts_to r y)
= fun #ictx -> mem_action_as_action _ _ _ _ (upd_gen ictx r x y f)
let share
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a{composable pcm v0 v1})
: act unit emp_inames
(pts_to r (v0 `op pcm` v1))
(fun _ -> pts_to r v0 `star` pts_to r v1)
= fun #ictx -> mem_action_as_action _ _ _ _ (split_action ictx r v0 v1)
let gather
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a)
: act (squash (composable pcm v0 v1))
emp_inames
(pts_to r v0 `star` pts_to r v1)
(fun _ -> pts_to r (op pcm v0 v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (gather_action ictx r v0 v1)
let witnessed = witnessed
let witness
(#a:Type)
(#pcm:pcm a)
(r:erased (ref a pcm))
(fact:stable_property pcm)
(v:Ghost.erased a)
(pf:squash (forall z. compatible pcm v z ==> fact z))
: act (witnessed r fact) emp_inames (pts_to r v) (fun _ -> pts_to r v)
= fun #ictx -> mem_action_as_action _ _ _ _ (witness ictx r fact v pf)
let recall
(#a:Type u#1)
(#pcm:pcm a)
(#fact:property a)
(r:erased (ref a pcm))
(v:Ghost.erased a)
(w:witnessed r fact)
: act (v1:Ghost.erased a{compatible pcm v v1})
emp_inames
(pts_to r v)
(fun v1 -> pts_to r v `star` pure (fact v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (recall ictx r v w)
///////////////////////////////////////////////////////////////////
// pure
///////////////////////////////////////////////////////////////////
let pure_true ()
= Mem.pure_true_emp ();
slprop_equiv_elim (pure True) emp;
coerce_eq () <| slprop_equiv_refl (pure True)
let intro_pure (p:prop) (pf:squash p)
: act unit emp_inames emp (fun _ -> pure p)
= fun #ictx -> mem_action_as_action _ _ _ _ (intro_pure #ictx p pf)
let elim_pure (p:prop)
: act (squash p) emp_inames (pure p) (fun _ -> emp)
= fun #ictx -> mem_action_as_action _ _ _ _ (elim_pure #ictx p)
///////////////////////////////////////////////////////////////////
// exists*
///////////////////////////////////////////////////////////////////
module F = FStar.FunctionalExtensionality
let exists_equiv (#a:_) (#p:a -> slprop)
: squash (op_exists_Star p == (exists* x. p x))
= let pf = I.slprop_equiv_exists p (fun x -> p x) () in
let pf = FStar.Squash.return_squash pf in
I.slprop_equiv_elim (op_exists_Star p) (exists* x. p x)
let thunk (p:slprop) = fun (_:unit) -> p
let intro_exists' (#a:Type u#a) (p:a -> slprop) (x:erased a)
: act unit emp_inames (p x) (thunk (op_exists_Star p))
= fun #ictx -> mem_action_as_action _ _ _ _ (intro_exists #ictx (F.on_dom a p) x)
let intro_exists'' (#a:Type u#a) (p:a -> slprop) (x:erased a)
: act unit emp_inames (p x) (thunk (exists* x. p x))
= coerce_eq (exists_equiv #a #p) (intro_exists' #a p x) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: (_: a -> PulseCore.InstantiatedSemantics.slprop) -> x: FStar.Ghost.erased a
-> PulseCore.Action.act Prims.unit
PulseCore.Action.emp_inames
(p (FStar.Ghost.reveal x))
(fun _ -> exists* (x: a). p x) | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"FStar.Ghost.erased",
"PulseCore.Action.intro_exists''",
"PulseCore.Action.act",
"Prims.unit",
"PulseCore.Action.emp_inames",
"FStar.Ghost.reveal",
"PulseCore.InstantiatedSemantics.op_exists_Star"
] | [] | false | false | false | false | false | let intro_exists (#a: Type u#a) (p: (a -> slprop)) (x: erased a)
: act unit emp_inames (p x) (fun _ -> exists* x. p x) =
| intro_exists'' p x | false |
StlcStrongDbParSubst.fst | StlcStrongDbParSubst.is_value | val is_value : exp -> Tot bool | val is_value : exp -> Tot bool | let is_value e = ELam? e || EUnit? e | {
"file_name": "examples/metatheory/StlcStrongDbParSubst.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 144,
"start_col": 0,
"start_line": 144
} | (*
Copyright 2014-2015
Simon Forest - Inria and ENS Paris
Catalin Hritcu - Inria
Nikhil Swamy - 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 StlcStrongDbParSubst
open FStar.Constructive
open FStar.Classical
open FStar.FunctionalExtensionality
open FStar.StrongExcludedMiddle
(* Constructive-style progress and preservation proof for STLC with
strong reduction, using deBruijn indices and parallel substitution. *)
type typ =
| TArr : typ -> typ -> typ
| TUnit : typ
type var = nat
type exp =
| EVar : var -> exp
| EApp : exp -> exp -> exp
| ELam : typ -> exp -> exp
| EUnit : exp
(* Parallel substitution operation `subst` *)
(* The termination argument uses a lexicographic ordering composed of:
0) a bit saying whether the expression is a variable or not;
1) an _undecidable_ well-founded order on substitutions that
equates all renamings, equates all non-renamings, and makes
renamings strictly smaller than non-renamings; we write down a
non-constructive function is_renaming mapping substitutions
(infinite objects) to 0 (renaming) or 1 (non-renaming)
2) the structure of the expression e *)
type sub = var -> Tot exp
type renaming (s:sub) = (forall (x:var). EVar? (s x))
val is_renaming : s:sub -> GTot (n:int{ (renaming s ==> n=0) /\
(~(renaming s) ==> n=1)})
let is_renaming s = (if strong_excluded_middle (renaming s) then 0 else 1)
val sub_inc : var -> Tot exp
let sub_inc y = EVar (y+1)
val renaming_sub_inc : unit -> Lemma (renaming (sub_inc))
let renaming_sub_inc _ = ()
let is_var (e:exp) : int = if EVar? e then 0 else 1
val sub_elam: s:sub -> var -> Tot (e:exp{renaming s ==> EVar? e})
(decreases %[1;is_renaming s; 0; EVar 0])
val subst : s:sub -> e:exp -> Pure exp (requires True)
(ensures (fun e' -> (renaming s /\ EVar? e) ==> EVar? e'))
(decreases %[is_var e; is_renaming s; 1; e])
let rec subst s e =
match e with
| EVar x -> s x
| ELam t e1 -> ELam t (subst (sub_elam s) e1)
| EApp e1 e2 -> EApp (subst s e1) (subst s e2)
| EUnit -> EUnit
and sub_elam s y = if y=0 then EVar y
else subst sub_inc (s (y-1))
val sub_beta : exp -> Tot sub
let sub_beta v = fun y -> if y = 0 then v (* substitute *)
else (EVar (y-1)) (* shift -1 *)
(* Small-step operational semantics; strong / full-beta reduction is
non-deterministic, so necessarily as inductive relation *)
type step : exp -> exp -> Type =
| SBeta : t:typ ->
e1:exp ->
e2:exp ->
step (EApp (ELam t e1) e2) (subst (sub_beta e2) e1)
| SApp1 : #e1:exp ->
e2:exp ->
#e1':exp ->
$hst:step e1 e1' ->
step (EApp e1 e2) (EApp e1' e2)
| SApp2 : e1:exp ->
#e2:exp ->
#e2':exp ->
$hst:step e2 e2' ->
step (EApp e1 e2) (EApp e1 e2')
(* Type system; as inductive relation (not strictly necessary for STLC) *)
type env = var -> Tot (option typ)
val empty : env
let empty _ = None
(* we only need extend at 0 *)
val extend : typ -> env -> Tot env
let extend t g y = if y = 0 then Some t
else g (y-1)
noeq type typing : env -> exp -> typ -> Type =
| TyVar : #g:env ->
x:var{Some? (g x)} ->
typing g (EVar x) (Some?.v (g x))
| TyLam : #g :env ->
t :typ ->
#e1:exp ->
#t':typ ->
$hbody:typing (extend t g) e1 t' ->
typing g (ELam t e1) (TArr t t')
| TyApp : #g:env ->
#e1:exp ->
#e2:exp ->
#t11:typ ->
#t12:typ ->
$h1:typing g e1 (TArr t11 t12) ->
$h2:typing g e2 t11 ->
typing g (EApp e1 e2) t12
| TyUnit : #g:env ->
typing g EUnit TUnit
(* Progress *) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Constructive.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "StlcStrongDbParSubst.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.StrongExcludedMiddle",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Constructive",
"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 | e: StlcStrongDbParSubst.exp -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"StlcStrongDbParSubst.exp",
"Prims.op_BarBar",
"StlcStrongDbParSubst.uu___is_ELam",
"StlcStrongDbParSubst.uu___is_EUnit",
"Prims.bool"
] | [] | false | false | false | true | false | let is_value e =
| ELam? e || EUnit? e | false |
PulseCore.Action.fst | PulseCore.Action.mem_action_as_action | val mem_action_as_action
(a: Type u#a)
(except: inames)
(req: slprop)
(ens: (a -> slprop))
(act: Mem.action_except a except req ens)
: action a except req ens | val mem_action_as_action
(a: Type u#a)
(except: inames)
(req: slprop)
(ens: (a -> slprop))
(act: Mem.action_except a except req ens)
: action a except req ens | let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 31,
"end_line": 107,
"start_col": 0,
"start_line": 95
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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 ->
except: PulseCore.Memory.inames ->
req: PulseCore.InstantiatedSemantics.slprop ->
ens: (_: a -> PulseCore.InstantiatedSemantics.slprop) ->
act: PulseCore.Memory.action_except a except req ens
-> PulseCore.Action.action a except req ens | Prims.Tot | [
"total"
] | [] | [
"PulseCore.Memory.inames",
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Memory.action_except",
"PulseCore.MonotonicStateMonad.of_msttotal",
"PulseCore.Memory.full_mem",
"PulseCore.Memory.mem_evolves",
"PulseCore.Semantics.full_mem",
"PulseCore.InstantiatedSemantics.state",
"Prims.l_and",
"PulseCore.Memory.inames_ok",
"PulseCore.Semantics.__proj__Mkstate__item__interp",
"PulseCore.Semantics.__proj__Mkstate__item__star",
"PulseCore.Memory.star",
"PulseCore.Semantics.__proj__Mkstate__item__invariant",
"PulseCore.InstantiatedSemantics.state0",
"Prims.prop",
"Prims.unit",
"PulseCore.Semantics.mst_sep_aux",
"PulseCore.Semantics.__proj__Mkstate__item__pred",
"PulseCore.Action.action"
] | [] | false | false | false | false | false | let mem_action_as_action
(a: Type u#a)
(except: inames)
(req: slprop)
(ens: (a -> slprop))
(act: Mem.action_except a except req ens)
: action a except req ens =
| fun frame ->
let thunk: unit -> MstTot a except req ens frame = fun _ -> act frame in
M.of_msttotal _ _ _ _ thunk | false |
PulseCore.Action.fst | PulseCore.Action.elim_exists' | val elim_exists' (#a: Type u#a) (p: (a -> slprop))
: act (erased a) emp_inames (op_exists_Star p) (fun x -> p x) | val elim_exists' (#a: Type u#a) (p: (a -> slprop))
: act (erased a) emp_inames (op_exists_Star p) (fun x -> p x) | let elim_exists' (#a:Type u#a) (p:a -> slprop)
: act (erased a) emp_inames (op_exists_Star p) (fun x -> p x)
= fun #ictx -> mem_action_as_action _ _ _ _ (witness_h_exists #ictx (F.on_dom a p)) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 83,
"end_line": 374,
"start_col": 0,
"start_line": 372
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p)
let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m
///////////////////////////////////////////////////////////////////
// Core operations on references
///////////////////////////////////////////////////////////////////
let ref (a:Type u#a) (p:pcm a) = ref a p
let ref_null (#a:Type u#a) (p:pcm a) = core_ref_null
let is_ref_null (#a:Type u#a) (#p:pcm a) (r:ref a p) = core_ref_is_null r
let pts_to = pts_to
let pts_to_not_null #a #p r v =
fun #ictx -> mem_action_as_action _ _ _ _ (pts_to_not_null_action ictx r v)
let alloc
(#a:Type u#1)
(#pcm:pcm a)
(x:a{compatible pcm x x /\ pcm.refine x})
: act (ref a pcm) emp_inames emp (fun r -> pts_to r x)
= fun #ictx ->
mem_action_as_action _ _ _ _
(alloc_action ictx x)
let read
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x:erased a)
(f:(v:a{compatible p x v}
-> GTot (y:a{compatible p y v /\
FStar.PCM.frame_compatible p x v y})))
: act (v:a{compatible p x v /\ p.refine v}) emp_inames
(pts_to r x)
(fun v -> pts_to r (f v))
= fun #ictx ->
mem_action_as_action _ _ _ _ (select_refine ictx r x f)
let write
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x y:Ghost.erased a)
(f:FStar.PCM.frame_preserving_upd p x y)
: act unit emp_inames
(pts_to r x)
(fun _ -> pts_to r y)
= fun #ictx -> mem_action_as_action _ _ _ _ (upd_gen ictx r x y f)
let share
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a{composable pcm v0 v1})
: act unit emp_inames
(pts_to r (v0 `op pcm` v1))
(fun _ -> pts_to r v0 `star` pts_to r v1)
= fun #ictx -> mem_action_as_action _ _ _ _ (split_action ictx r v0 v1)
let gather
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a)
: act (squash (composable pcm v0 v1))
emp_inames
(pts_to r v0 `star` pts_to r v1)
(fun _ -> pts_to r (op pcm v0 v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (gather_action ictx r v0 v1)
let witnessed = witnessed
let witness
(#a:Type)
(#pcm:pcm a)
(r:erased (ref a pcm))
(fact:stable_property pcm)
(v:Ghost.erased a)
(pf:squash (forall z. compatible pcm v z ==> fact z))
: act (witnessed r fact) emp_inames (pts_to r v) (fun _ -> pts_to r v)
= fun #ictx -> mem_action_as_action _ _ _ _ (witness ictx r fact v pf)
let recall
(#a:Type u#1)
(#pcm:pcm a)
(#fact:property a)
(r:erased (ref a pcm))
(v:Ghost.erased a)
(w:witnessed r fact)
: act (v1:Ghost.erased a{compatible pcm v v1})
emp_inames
(pts_to r v)
(fun v1 -> pts_to r v `star` pure (fact v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (recall ictx r v w)
///////////////////////////////////////////////////////////////////
// pure
///////////////////////////////////////////////////////////////////
let pure_true ()
= Mem.pure_true_emp ();
slprop_equiv_elim (pure True) emp;
coerce_eq () <| slprop_equiv_refl (pure True)
let intro_pure (p:prop) (pf:squash p)
: act unit emp_inames emp (fun _ -> pure p)
= fun #ictx -> mem_action_as_action _ _ _ _ (intro_pure #ictx p pf)
let elim_pure (p:prop)
: act (squash p) emp_inames (pure p) (fun _ -> emp)
= fun #ictx -> mem_action_as_action _ _ _ _ (elim_pure #ictx p)
///////////////////////////////////////////////////////////////////
// exists*
///////////////////////////////////////////////////////////////////
module F = FStar.FunctionalExtensionality
let exists_equiv (#a:_) (#p:a -> slprop)
: squash (op_exists_Star p == (exists* x. p x))
= let pf = I.slprop_equiv_exists p (fun x -> p x) () in
let pf = FStar.Squash.return_squash pf in
I.slprop_equiv_elim (op_exists_Star p) (exists* x. p x)
let thunk (p:slprop) = fun (_:unit) -> p
let intro_exists' (#a:Type u#a) (p:a -> slprop) (x:erased a)
: act unit emp_inames (p x) (thunk (op_exists_Star p))
= fun #ictx -> mem_action_as_action _ _ _ _ (intro_exists #ictx (F.on_dom a p) x)
let intro_exists'' (#a:Type u#a) (p:a -> slprop) (x:erased a)
: act unit emp_inames (p x) (thunk (exists* x. p x))
= coerce_eq (exists_equiv #a #p) (intro_exists' #a p x)
let intro_exists (#a:Type u#a) (p:a -> slprop) (x:erased a)
: act unit emp_inames (p x) (fun _ -> exists* x. p x)
= intro_exists'' p x | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: (_: a -> PulseCore.InstantiatedSemantics.slprop)
-> PulseCore.Action.act (FStar.Ghost.erased a)
PulseCore.Action.emp_inames
(exists . p)
(fun x -> p (FStar.Ghost.reveal x)) | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Action.inames_disj",
"PulseCore.Action.emp_inames",
"PulseCore.Action.mem_action_as_action",
"FStar.Ghost.erased",
"PulseCore.Memory.h_exists",
"FStar.FunctionalExtensionality.on_dom",
"PulseCore.Memory.slprop",
"FStar.Ghost.reveal",
"PulseCore.Memory.witness_h_exists",
"PulseCore.Action.action",
"PulseCore.InstantiatedSemantics.op_exists_Star",
"PulseCore.Action.act"
] | [] | false | false | false | false | false | let elim_exists' (#a: Type u#a) (p: (a -> slprop))
: act (erased a) emp_inames (op_exists_Star p) (fun x -> p x) =
| fun #ictx -> mem_action_as_action _ _ _ _ (witness_h_exists #ictx (F.on_dom a p)) | false |
PulseCore.Action.fst | PulseCore.Action.drop | val drop (p:slprop)
: act unit emp_inames p (fun _ -> emp) | val drop (p:slprop)
: act unit emp_inames p (fun _ -> emp) | let drop p
= fun #ictx -> mem_action_as_action _ _ _ _ (drop #ictx p) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 58,
"end_line": 381,
"start_col": 0,
"start_line": 380
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p)
let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m
///////////////////////////////////////////////////////////////////
// Core operations on references
///////////////////////////////////////////////////////////////////
let ref (a:Type u#a) (p:pcm a) = ref a p
let ref_null (#a:Type u#a) (p:pcm a) = core_ref_null
let is_ref_null (#a:Type u#a) (#p:pcm a) (r:ref a p) = core_ref_is_null r
let pts_to = pts_to
let pts_to_not_null #a #p r v =
fun #ictx -> mem_action_as_action _ _ _ _ (pts_to_not_null_action ictx r v)
let alloc
(#a:Type u#1)
(#pcm:pcm a)
(x:a{compatible pcm x x /\ pcm.refine x})
: act (ref a pcm) emp_inames emp (fun r -> pts_to r x)
= fun #ictx ->
mem_action_as_action _ _ _ _
(alloc_action ictx x)
let read
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x:erased a)
(f:(v:a{compatible p x v}
-> GTot (y:a{compatible p y v /\
FStar.PCM.frame_compatible p x v y})))
: act (v:a{compatible p x v /\ p.refine v}) emp_inames
(pts_to r x)
(fun v -> pts_to r (f v))
= fun #ictx ->
mem_action_as_action _ _ _ _ (select_refine ictx r x f)
let write
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x y:Ghost.erased a)
(f:FStar.PCM.frame_preserving_upd p x y)
: act unit emp_inames
(pts_to r x)
(fun _ -> pts_to r y)
= fun #ictx -> mem_action_as_action _ _ _ _ (upd_gen ictx r x y f)
let share
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a{composable pcm v0 v1})
: act unit emp_inames
(pts_to r (v0 `op pcm` v1))
(fun _ -> pts_to r v0 `star` pts_to r v1)
= fun #ictx -> mem_action_as_action _ _ _ _ (split_action ictx r v0 v1)
let gather
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a)
: act (squash (composable pcm v0 v1))
emp_inames
(pts_to r v0 `star` pts_to r v1)
(fun _ -> pts_to r (op pcm v0 v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (gather_action ictx r v0 v1)
let witnessed = witnessed
let witness
(#a:Type)
(#pcm:pcm a)
(r:erased (ref a pcm))
(fact:stable_property pcm)
(v:Ghost.erased a)
(pf:squash (forall z. compatible pcm v z ==> fact z))
: act (witnessed r fact) emp_inames (pts_to r v) (fun _ -> pts_to r v)
= fun #ictx -> mem_action_as_action _ _ _ _ (witness ictx r fact v pf)
let recall
(#a:Type u#1)
(#pcm:pcm a)
(#fact:property a)
(r:erased (ref a pcm))
(v:Ghost.erased a)
(w:witnessed r fact)
: act (v1:Ghost.erased a{compatible pcm v v1})
emp_inames
(pts_to r v)
(fun v1 -> pts_to r v `star` pure (fact v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (recall ictx r v w)
///////////////////////////////////////////////////////////////////
// pure
///////////////////////////////////////////////////////////////////
let pure_true ()
= Mem.pure_true_emp ();
slprop_equiv_elim (pure True) emp;
coerce_eq () <| slprop_equiv_refl (pure True)
let intro_pure (p:prop) (pf:squash p)
: act unit emp_inames emp (fun _ -> pure p)
= fun #ictx -> mem_action_as_action _ _ _ _ (intro_pure #ictx p pf)
let elim_pure (p:prop)
: act (squash p) emp_inames (pure p) (fun _ -> emp)
= fun #ictx -> mem_action_as_action _ _ _ _ (elim_pure #ictx p)
///////////////////////////////////////////////////////////////////
// exists*
///////////////////////////////////////////////////////////////////
module F = FStar.FunctionalExtensionality
let exists_equiv (#a:_) (#p:a -> slprop)
: squash (op_exists_Star p == (exists* x. p x))
= let pf = I.slprop_equiv_exists p (fun x -> p x) () in
let pf = FStar.Squash.return_squash pf in
I.slprop_equiv_elim (op_exists_Star p) (exists* x. p x)
let thunk (p:slprop) = fun (_:unit) -> p
let intro_exists' (#a:Type u#a) (p:a -> slprop) (x:erased a)
: act unit emp_inames (p x) (thunk (op_exists_Star p))
= fun #ictx -> mem_action_as_action _ _ _ _ (intro_exists #ictx (F.on_dom a p) x)
let intro_exists'' (#a:Type u#a) (p:a -> slprop) (x:erased a)
: act unit emp_inames (p x) (thunk (exists* x. p x))
= coerce_eq (exists_equiv #a #p) (intro_exists' #a p x)
let intro_exists (#a:Type u#a) (p:a -> slprop) (x:erased a)
: act unit emp_inames (p x) (fun _ -> exists* x. p x)
= intro_exists'' p x
let elim_exists' (#a:Type u#a) (p:a -> slprop)
: act (erased a) emp_inames (op_exists_Star p) (fun x -> p x)
= fun #ictx -> mem_action_as_action _ _ _ _ (witness_h_exists #ictx (F.on_dom a p))
let elim_exists (#a:Type u#a) (p:a -> slprop)
: act (erased a) emp_inames (exists* x. p x) (fun x -> p x)
= coerce_eq (exists_equiv #a #p) (elim_exists' #a p) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: PulseCore.InstantiatedSemantics.slprop
-> PulseCore.Action.act Prims.unit
PulseCore.Action.emp_inames
p
(fun _ -> PulseCore.InstantiatedSemantics.emp) | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Action.inames_disj",
"PulseCore.Action.emp_inames",
"PulseCore.Action.mem_action_as_action",
"Prims.unit",
"PulseCore.Memory.emp",
"PulseCore.Memory.drop",
"PulseCore.Action.action",
"PulseCore.InstantiatedSemantics.emp"
] | [] | false | false | false | false | false | let drop p =
| fun #ictx -> mem_action_as_action _ _ _ _ (drop #ictx p) | false |
PulseCore.Action.fst | PulseCore.Action.stt_of_action1 | val stt_of_action1 (#a: Type u#1) (#pre #post: _) (m: action a Set.empty pre post) : stt a pre post | val stt_of_action1 (#a: Type u#1) (#pre #post: _) (m: action a Set.empty pre post) : stt a pre post | let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 41,
"end_line": 84,
"start_col": 0,
"start_line": 77
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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 | m: PulseCore.Action.action a (FStar.Ghost.hide FStar.Set.empty) pre post
-> PulseCore.InstantiatedSemantics.stt a pre post | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Action.action",
"FStar.Ghost.hide",
"FStar.Set.set",
"PulseCore.Memory.iname",
"FStar.Set.empty",
"Prims.unit",
"PulseCore.Semantics.act_as_m1",
"PulseCore.InstantiatedSemantics.state",
"PulseCore.Semantics.m",
"PulseCore.Semantics.__proj__Mkaction__item__pre",
"PulseCore.Semantics.__proj__Mkaction__item__post",
"FStar.FunctionalExtensionality.on_dom",
"PulseCore.Semantics.__proj__Mkstate__item__pred",
"PulseCore.Semantics.action",
"PulseCore.Semantics.Mkaction",
"PulseCore.Semantics.mst_sep",
"PulseCore.Memory.star",
"PulseCore.MonotonicStateMonad.weaken",
"PulseCore.Semantics.full_mem",
"PulseCore.Semantics.__proj__Mkstate__item__evolves",
"Prims.l_and",
"PulseCore.Memory.inames_ok",
"PulseCore.Semantics.__proj__Mkstate__item__interp",
"PulseCore.Semantics.__proj__Mkstate__item__star",
"PulseCore.Semantics.__proj__Mkstate__item__invariant",
"PulseCore.InstantiatedSemantics.state0",
"Prims.prop",
"Prims.l_True",
"PulseCore.InstantiatedSemantics.stt"
] | [] | false | false | false | false | false | let stt_of_action1 (#a: Type u#1) #pre #post (m: action a Set.empty pre post) : stt a pre post =
| let step (frame: slprop) : Sem.mst_sep state a (pre `star` frame) (fun x -> (post x) `star` frame) =
M.weaken (m frame)
in
let action:Sem.action state a = { pre = pre; post = F.on_dom _ post; step = step } in
fun _ -> Sem.act_as_m1 u#2 u#100 action | false |
PulseCore.Action.fst | PulseCore.Action.lift | val lift (#a:Type u#100) #opens (#pre:slprop) (#post:a -> slprop)
(m:act a opens pre post)
: I.stt a pre post | val lift (#a:Type u#100) #opens (#pre:slprop) (#post:a -> slprop)
(m:act a opens pre post)
: I.stt a pre post | let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 31,
"end_line": 196,
"start_col": 0,
"start_line": 193
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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 | m: PulseCore.Action.act a opens pre post -> PulseCore.InstantiatedSemantics.stt a pre post | Prims.Tot | [
"total"
] | [] | [
"PulseCore.Action.inames",
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Action.act",
"PulseCore.Action.stt_of_action",
"PulseCore.Action.emp_inames",
"PulseCore.InstantiatedSemantics.stt"
] | [] | false | false | false | false | false | let lift (#a: Type u#100) #opens #pre #post (m: act a opens pre post) : stt a pre post =
| stt_of_action (m #emp_inames) | false |
PulseCore.Action.fst | PulseCore.Action.stt_of_action2 | val stt_of_action2 (#a: Type u#2) (#pre #post: _) (m: action a Set.empty pre post) : stt a pre post | val stt_of_action2 (#a: Type u#2) (#pre #post: _) (m: action a Set.empty pre post) : stt a pre post | let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 41,
"end_line": 93,
"start_col": 0,
"start_line": 86
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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 | m: PulseCore.Action.action a (FStar.Ghost.hide FStar.Set.empty) pre post
-> PulseCore.InstantiatedSemantics.stt a pre post | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Action.action",
"FStar.Ghost.hide",
"FStar.Set.set",
"PulseCore.Memory.iname",
"FStar.Set.empty",
"Prims.unit",
"PulseCore.Semantics.act_as_m2",
"PulseCore.InstantiatedSemantics.state",
"PulseCore.Semantics.m",
"PulseCore.Semantics.__proj__Mkaction__item__pre",
"PulseCore.Semantics.__proj__Mkaction__item__post",
"FStar.FunctionalExtensionality.on_dom",
"PulseCore.Semantics.__proj__Mkstate__item__pred",
"PulseCore.Semantics.action",
"PulseCore.Semantics.Mkaction",
"PulseCore.Semantics.mst_sep",
"PulseCore.Memory.star",
"PulseCore.MonotonicStateMonad.weaken",
"PulseCore.Semantics.full_mem",
"PulseCore.Semantics.__proj__Mkstate__item__evolves",
"Prims.l_and",
"PulseCore.Memory.inames_ok",
"PulseCore.Semantics.__proj__Mkstate__item__interp",
"PulseCore.Semantics.__proj__Mkstate__item__star",
"PulseCore.Semantics.__proj__Mkstate__item__invariant",
"PulseCore.InstantiatedSemantics.state0",
"Prims.prop",
"Prims.l_True",
"PulseCore.InstantiatedSemantics.stt"
] | [] | false | false | false | false | false | let stt_of_action2 (#a: Type u#2) #pre #post (m: action a Set.empty pre post) : stt a pre post =
| let step (frame: slprop) : Sem.mst_sep state a (pre `star` frame) (fun x -> (post x) `star` frame) =
M.weaken (m frame)
in
let action:Sem.action state a = { pre = pre; post = F.on_dom _ post; step = step } in
fun _ -> Sem.act_as_m2 u#2 u#100 action | false |
PulseCore.Action.fst | PulseCore.Action.lift1 | val lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: I.stt a pre post | val lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: I.stt a pre post | let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 32,
"end_line": 206,
"start_col": 0,
"start_line": 203
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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 | m: PulseCore.Action.act a opens pre post -> PulseCore.InstantiatedSemantics.stt a pre post | Prims.Tot | [
"total"
] | [] | [
"PulseCore.Action.inames",
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Action.act",
"PulseCore.Action.stt_of_action1",
"PulseCore.Action.emp_inames",
"PulseCore.InstantiatedSemantics.stt"
] | [] | false | false | false | false | false | let lift1 (#a: Type u#1) #opens #pre #post (m: act a opens pre post) : stt a pre post =
| stt_of_action1 (m #emp_inames) | false |
PulseCore.Action.fst | PulseCore.Action.sub | val sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post' | val sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post' | let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 3,
"end_line": 191,
"start_col": 0,
"start_line": 179
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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 |
pre':
PulseCore.InstantiatedSemantics.slprop{PulseCore.InstantiatedSemantics.slprop_equiv pre pre'} ->
post':
(_: a -> PulseCore.InstantiatedSemantics.slprop)
{forall (x: a). PulseCore.InstantiatedSemantics.slprop_equiv (post x) (post' x)} ->
f: PulseCore.Action.act a opens pre post
-> PulseCore.Action.act a opens pre' post' | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Action.inames",
"PulseCore.InstantiatedSemantics.slprop_equiv",
"Prims.l_Forall",
"PulseCore.Action.act",
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.eq2",
"PulseCore.InstantiatedSemantics.slprop_equiv_elim",
"Prims.squash"
] | [] | false | false | false | false | false | let sub
(#a: Type)
(#pre: slprop)
(#post: (a -> slprop))
(#opens: inames)
(pre': slprop{slprop_equiv pre pre'})
(post': (a -> slprop){forall x. slprop_equiv (post x) (post' x)})
(f: act a opens pre post)
: act a opens pre' post' =
| I.slprop_equiv_elim pre pre';
introduce forall x . post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f | false |
PulseCore.Action.fst | PulseCore.Action.lift2 | val lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: I.stt a pre post | val lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: I.stt a pre post | let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 32,
"end_line": 211,
"start_col": 0,
"start_line": 208
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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 | m: PulseCore.Action.act a opens pre post -> PulseCore.InstantiatedSemantics.stt a pre post | Prims.Tot | [
"total"
] | [] | [
"PulseCore.Action.inames",
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Action.act",
"PulseCore.Action.stt_of_action2",
"PulseCore.Action.emp_inames",
"PulseCore.InstantiatedSemantics.stt"
] | [] | false | false | false | false | false | let lift2 (#a: Type u#2) #opens #pre #post (m: act a opens pre post) : stt a pre post =
| stt_of_action2 (m #emp_inames) | false |
PulseCore.Action.fst | PulseCore.Action.is_ref_null | val is_ref_null (#a:Type) (#p:FStar.PCM.pcm a) (r:ref a p)
: b:bool { b <==> r == ref_null p } | val is_ref_null (#a:Type) (#p:FStar.PCM.pcm a) (r:ref a p)
: b:bool { b <==> r == ref_null p } | let is_ref_null (#a:Type u#a) (#p:pcm a) (r:ref a p) = core_ref_is_null r | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 73,
"end_line": 246,
"start_col": 0,
"start_line": 246
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p)
let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m
///////////////////////////////////////////////////////////////////
// Core operations on references
///////////////////////////////////////////////////////////////////
let ref (a:Type u#a) (p:pcm a) = ref a p | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: PulseCore.Action.ref a p -> b: Prims.bool{b <==> r == PulseCore.Action.ref_null p} | Prims.Tot | [
"total"
] | [] | [
"FStar.PCM.pcm",
"PulseCore.Action.ref",
"PulseCore.Memory.core_ref_is_null",
"Prims.bool",
"Prims.l_iff",
"Prims.b2t",
"Prims.eq2",
"PulseCore.Action.ref_null"
] | [] | false | false | false | false | false | let is_ref_null (#a: Type u#a) (#p: pcm a) (r: ref a p) =
| core_ref_is_null r | false |
PulseCore.Action.fst | PulseCore.Action.weaken | val weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post | val weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post | let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 3,
"end_line": 177,
"start_col": 0,
"start_line": 170
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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 | opens': PulseCore.Action.inames -> f: PulseCore.Action.act a opens pre post
-> PulseCore.Action.act a
(FStar.Ghost.hide (FStar.Set.union (FStar.Ghost.reveal opens) (FStar.Ghost.reveal opens')))
pre
post | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Action.inames",
"PulseCore.Action.act",
"FStar.Ghost.hide",
"FStar.Set.set",
"PulseCore.Action.iname",
"FStar.Set.union",
"FStar.Ghost.reveal"
] | [] | false | false | false | false | false | let weaken
(#a: Type)
(#pre: slprop)
(#post: (a -> slprop))
(#opens opens': inames)
(f: act a opens pre post)
: act a (Set.union opens opens') pre post =
| f | false |
PulseCore.Action.fst | PulseCore.Action.read | val read
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x:erased a)
(f:(v:a{compatible p x v}
-> GTot (y:a{compatible p y v /\
FStar.PCM.frame_compatible p x v y})))
: act (v:a{compatible p x v /\ p.refine v}) emp_inames
(pts_to r x)
(fun v -> pts_to r (f v)) | val read
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x:erased a)
(f:(v:a{compatible p x v}
-> GTot (y:a{compatible p y v /\
FStar.PCM.frame_compatible p x v y})))
: act (v:a{compatible p x v /\ p.refine v}) emp_inames
(pts_to r x)
(fun v -> pts_to r (f v)) | let read
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x:erased a)
(f:(v:a{compatible p x v}
-> GTot (y:a{compatible p y v /\
FStar.PCM.frame_compatible p x v y})))
: act (v:a{compatible p x v /\ p.refine v}) emp_inames
(pts_to r x)
(fun v -> pts_to r (f v))
= fun #ictx ->
mem_action_as_action _ _ _ _ (select_refine ictx r x f) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 59,
"end_line": 272,
"start_col": 0,
"start_line": 260
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p)
let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m
///////////////////////////////////////////////////////////////////
// Core operations on references
///////////////////////////////////////////////////////////////////
let ref (a:Type u#a) (p:pcm a) = ref a p
let ref_null (#a:Type u#a) (p:pcm a) = core_ref_null
let is_ref_null (#a:Type u#a) (#p:pcm a) (r:ref a p) = core_ref_is_null r
let pts_to = pts_to
let pts_to_not_null #a #p r v =
fun #ictx -> mem_action_as_action _ _ _ _ (pts_to_not_null_action ictx r v)
let alloc
(#a:Type u#1)
(#pcm:pcm a)
(x:a{compatible pcm x x /\ pcm.refine x})
: act (ref a pcm) emp_inames emp (fun r -> pts_to r x)
= fun #ictx ->
mem_action_as_action _ _ _ _
(alloc_action ictx x) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: PulseCore.Action.ref a p ->
x: FStar.Ghost.erased a ->
f:
(v: a{FStar.PCM.compatible p (FStar.Ghost.reveal x) v}
-> Prims.GTot (y: a{FStar.PCM.compatible p y v /\ FStar.PCM.frame_compatible p x v y}))
-> PulseCore.Action.act (v:
a{FStar.PCM.compatible p (FStar.Ghost.reveal x) v /\ Mkpcm?.refine p v})
PulseCore.Action.emp_inames
(PulseCore.Action.pts_to r (FStar.Ghost.reveal x))
(fun v -> PulseCore.Action.pts_to r (f v)) | Prims.Tot | [
"total"
] | [] | [
"FStar.PCM.pcm",
"PulseCore.Action.ref",
"FStar.Ghost.erased",
"FStar.PCM.compatible",
"FStar.Ghost.reveal",
"Prims.l_and",
"FStar.PCM.frame_compatible",
"PulseCore.Action.inames_disj",
"PulseCore.Action.emp_inames",
"PulseCore.Action.mem_action_as_action",
"FStar.PCM.__proj__Mkpcm__item__refine",
"PulseCore.Memory.pts_to",
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Memory.select_refine",
"PulseCore.Action.action",
"PulseCore.Action.pts_to",
"PulseCore.Action.act"
] | [] | false | false | false | false | false | let read
(#a: Type)
(#p: pcm a)
(r: ref a p)
(x: erased a)
(f:
(v: a{compatible p x v}
-> GTot (y: a{compatible p y v /\ FStar.PCM.frame_compatible p x v y})))
: act (v: a{compatible p x v /\ p.refine v}) emp_inames (pts_to r x) (fun v -> pts_to r (f v)) =
| fun #ictx -> mem_action_as_action _ _ _ _ (select_refine ictx r x f) | false |
Vale.Curve25519.X64.FastUtil.fsti | Vale.Curve25519.X64.FastUtil.va_req_Fast_add1 | val va_req_Fast_add1 (va_b0: va_code) (va_s0: va_state) (dst_b inA_b: buffer64) (inB: nat64) : prop | val va_req_Fast_add1 (va_b0: va_code) (va_s0: va_state) (dst_b inA_b: buffer64) (inB: nat64) : prop | let va_req_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
: prop =
(va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0)) | {
"file_name": "obj/Vale.Curve25519.X64.FastUtil.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 35,
"start_col": 0,
"start_line": 22
} | module Vale.Curve25519.X64.FastUtil
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Fast_add1
val va_code_Fast_add1 : va_dummy:unit -> Tot va_code | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastUtil.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB: Vale.X64.Memory.nat64
-> Prims.prop | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Memory.buffer64",
"Vale.X64.Memory.nat64",
"Prims.l_and",
"Vale.X64.Decls.va_require_total",
"Vale.Curve25519.X64.FastUtil.va_code_Fast_add1",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.adx_enabled",
"Vale.X64.CPU_Features_s.bmi2_enabled",
"Vale.X64.Memory.is_initial_heap",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Decls.va_get_mem",
"Prims.l_or",
"Vale.X64.Decls.buffers_disjoint",
"Prims.eq2",
"Vale.X64.Decls.validDstAddrs64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRdi",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validSrcAddrs64",
"Vale.X64.Machine_s.rRsi",
"Vale.Def.Words_s.nat64",
"Vale.X64.Machine_s.rRdx",
"Prims.nat",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.X64.Decls.buffer64_read",
"Prims.prop"
] | [] | false | false | false | true | true | let va_req_Fast_add1 (va_b0: va_code) (va_s0: va_state) (dst_b inA_b: buffer64) (inB: nat64) : prop =
| (va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\
(let a0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let a2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let a3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let a:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdi va_s0)
dst_b
4
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0)
inA_b
4
(va_get_mem_layout va_s0)
Secret /\ inB == va_get_reg64 rRdx va_s0)) | false |
PulseCore.Action.fst | PulseCore.Action.action_as_mem_action | val action_as_mem_action
(a: Type u#a)
(except: inames)
(pre: slprop)
(post: (a -> slprop))
(act: action a except pre post)
: Mem.action_except a except pre post | val action_as_mem_action
(a: Type u#a)
(except: inames)
(pre: slprop)
(post: (a -> slprop))
(act: action a except pre post)
: Mem.action_except a except pre post | let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 27,
"end_line": 128,
"start_col": 0,
"start_line": 109
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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 ->
except: PulseCore.Memory.inames ->
pre: PulseCore.InstantiatedSemantics.slprop ->
post: (_: a -> PulseCore.InstantiatedSemantics.slprop) ->
act: PulseCore.Action.action a except pre post
-> PulseCore.Memory.action_except a except pre post | Prims.Tot | [
"total"
] | [] | [
"PulseCore.Memory.inames",
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Action.action",
"PulseCore.Memory.slprop",
"PulseCore.MonotonicStateMonad.to_msttotal",
"PulseCore.Semantics.__proj__Mkstate__item__s",
"PulseCore.InstantiatedSemantics.state",
"PulseCore.Semantics.__proj__Mkstate__item__is_full_mem",
"PulseCore.Semantics.__proj__Mkstate__item__evolves",
"Prims.l_and",
"PulseCore.Memory.inames_ok",
"PulseCore.Memory.interp",
"PulseCore.Memory.star",
"PulseCore.Memory.locks_invariant",
"Prims.prop",
"PulseCore.MonotonicStateMonad.mst",
"PulseCore.MonotonicStateMonad.weaken",
"PulseCore.Semantics.full_mem",
"PulseCore.Semantics.__proj__Mkstate__item__interp",
"PulseCore.Semantics.__proj__Mkstate__item__star",
"PulseCore.Semantics.__proj__Mkstate__item__invariant",
"PulseCore.InstantiatedSemantics.state0",
"PulseCore.Memory.action_except"
] | [] | false | false | false | false | false | let action_as_mem_action
(a: Type u#a)
(except: inames)
(pre: slprop)
(post: (a -> slprop))
(act: action a except pre post)
: Mem.action_except a except pre post =
| fun frame ->
let m:M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\ interp ((pre `star` (locks_invariant except s0)) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp (((post x) `star` (locks_invariant except s1)) `star` frame) s1) =
M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m | false |
Spec.Frodo.Test.fst | Spec.Frodo.Test.test | val test: Prims.unit -> ML bool | val test: Prims.unit -> ML bool | let test () : ML bool =
[@inline_let] let a = Frodo64 in
assert_norm (List.Tot.length test1_enccoins == 16);
assert_norm (List.Tot.length test1_keypaircoins == 2 * crypto_bytes a + bytes_seed_a);
assert_norm (List.Tot.length test1_enccoins == bytes_mu a);
assert_norm (List.Tot.length test1_ss_expected == crypto_bytes a);
assert_norm (List.Tot.length test1_pk_expected == crypto_publickeybytes a);
assert_norm (List.Tot.length test1_ct_expected == crypto_ciphertextbytes a);
assert_norm (List.Tot.length test1_sk_expected == crypto_secretkeybytes a);
IO.print_string "\nTest1. SHAKE128";
let res1 =
test_frodo a SHAKE128 test1_keypaircoins
test1_enccoins
test1_ss_expected
test1_pk_expected
test1_ct_expected
test1_sk_expected
in
let result = res1 in
if result
then IO.print_string "\n\nFrodoKEM : Success!\n"
else IO.print_string "\n\nFrodoKEM: Failure :(\n";
result | {
"file_name": "specs/tests/Spec.Frodo.Test.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 8,
"end_line": 460,
"start_col": 0,
"start_line": 437
} | module Spec.Frodo.Test
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Frodo.KEM
open Spec.Frodo.KEM.KeyGen
open Spec.Frodo.KEM.Encaps
open Spec.Frodo.KEM.Decaps
open Spec.Frodo.Params
open FStar.All
module PS = Lib.PrintSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1"
let compare (#len: size_nat) (test_expected: lbytes len) (test_result: lbytes len) =
for_all2 (fun a b -> uint_to_nat #U8 a = uint_to_nat #U8 b) test_expected test_result
let test_frodo
(a:frodo_alg)
(gen_a:frodo_gen_a)
(keypaircoins: list uint8 {List.Tot.length keypaircoins == 2 * crypto_bytes a + bytes_seed_a})
(enccoins: list uint8 {List.Tot.length enccoins == bytes_mu a})
(ss_expected: list uint8 {List.Tot.length ss_expected == crypto_bytes a})
(pk_expected: list uint8 {List.Tot.length pk_expected == crypto_publickeybytes a})
(ct_expected: list uint8 {List.Tot.length ct_expected == crypto_ciphertextbytes a})
(sk_expected: list uint8 {List.Tot.length sk_expected == crypto_secretkeybytes a})
: ML bool =
let keypaircoins = createL keypaircoins in
let enccoins = createL enccoins in
let ss_expected = createL ss_expected in
let pk_expected = createL pk_expected in
let ct_expected = createL ct_expected in
let sk_expected = createL sk_expected in
let pk, sk = crypto_kem_keypair_ a gen_a keypaircoins in
let ct, ss1 = crypto_kem_enc_ a gen_a enccoins pk in
let ss2 = crypto_kem_dec a gen_a ct sk in
let r_pk = compare pk_expected pk in
let r_sk = compare sk_expected sk in
let r_ct = compare ct_expected ct in
let r_ss = PS.print_compare true (crypto_bytes a) ss1 ss2 in
let r_ss1 = PS.print_compare true (crypto_bytes a) ss_expected ss2 in
r_pk && r_sk && r_ct && r_ss && r_ss1
//
// Test1. FrodoKEM-64. SHAKE128
//
let test1_keypaircoins =
List.Tot.map u8_from_UInt8
[
0xa6uy; 0x65uy; 0x65uy; 0x9fuy; 0xfbuy; 0xe4uy; 0x06uy; 0x5cuy; 0xcauy; 0x81uy; 0x5auy; 0x45uy;
0xe4uy; 0x94uy; 0xd8uy; 0x01uy; 0x90uy; 0x30uy; 0x33uy; 0x55uy; 0x33uy; 0x84uy; 0x2euy; 0xe4uy;
0x4cuy; 0x55uy; 0x8fuy; 0xd8uy; 0xaeuy; 0x4buy; 0x4euy; 0x91uy; 0x62uy; 0xfeuy; 0xc7uy; 0x9auy;
0xc5uy; 0xcduy; 0x1fuy; 0xe2uy; 0xd2uy; 0x00uy; 0x63uy; 0x39uy; 0xaauy; 0xb1uy; 0xf3uy; 0x17uy
]
let test1_enccoins =
List.Tot.map u8_from_UInt8
[
0x8duy; 0xf3uy; 0xfauy; 0xe3uy; 0x83uy; 0x27uy; 0xc5uy; 0x3cuy; 0xc1uy; 0xc4uy; 0x8cuy; 0x60uy;
0xb2uy; 0x52uy; 0x2buy; 0xb5uy
]
let test1_ss_expected =
List.Tot.map u8_from_UInt8
[
0xf8uy; 0x96uy; 0x15uy; 0x94uy; 0x80uy; 0x9fuy; 0xebuy; 0x77uy; 0x56uy; 0xbeuy; 0x37uy; 0x69uy;
0xa0uy; 0xeauy; 0x60uy; 0x16uy
]
let test1_pk_expected =
List.Tot.map u8_from_UInt8
[
0x0duy; 0xacuy; 0x6fuy; 0x83uy; 0x94uy; 0x00uy; 0x1auy; 0xcauy; 0x97uy; 0xa1uy; 0xaauy; 0x42uy;
0x80uy; 0x9duy; 0x6buy; 0xa5uy; 0xfcuy; 0x64uy; 0x43uy; 0xdbuy; 0xbeuy; 0x6fuy; 0x12uy; 0x2auy;
0x94uy; 0x58uy; 0x36uy; 0xf2uy; 0xb1uy; 0xf8uy; 0xe5uy; 0xf0uy; 0x57uy; 0x4buy; 0x35uy; 0x51uy;
0xdduy; 0x8cuy; 0x36uy; 0x28uy; 0x34uy; 0x46uy; 0xd6uy; 0xafuy; 0x5duy; 0x49uy; 0x0euy; 0x27uy;
0xd8uy; 0xd3uy; 0xaduy; 0xe1uy; 0xeduy; 0x8buy; 0x2duy; 0x13uy; 0xf5uy; 0x5auy; 0xb6uy; 0xdduy;
0xc0uy; 0x54uy; 0x76uy; 0x09uy; 0xa6uy; 0xa4uy; 0x01uy; 0xb9uy; 0xb7uy; 0xd1uy; 0x26uy; 0xd5uy;
0x1euy; 0xa8uy; 0x20uy; 0x4duy; 0xe8uy; 0xefuy; 0xaduy; 0xb9uy; 0xf0uy; 0x65uy; 0xe9uy; 0xc4uy;
0xf4uy; 0x11uy; 0x98uy; 0x99uy; 0xf0uy; 0x2cuy; 0x63uy; 0x7buy; 0x98uy; 0xd7uy; 0x60uy; 0x43uy;
0x5duy; 0x8cuy; 0x85uy; 0xe9uy; 0xc5uy; 0x83uy; 0x83uy; 0x62uy; 0xe2uy; 0x13uy; 0x33uy; 0x54uy;
0x4buy; 0x71uy; 0xaeuy; 0x63uy; 0xbauy; 0x5auy; 0x4euy; 0x32uy; 0x59uy; 0x78uy; 0x6buy; 0x4duy;
0x39uy; 0xcfuy; 0xe1uy; 0x82uy; 0x58uy; 0x0auy; 0xc3uy; 0x61uy; 0x6auy; 0x89uy; 0x2fuy; 0x1buy;
0x70uy; 0xdduy; 0x16uy; 0x3euy; 0x96uy; 0xb1uy; 0x4cuy; 0x71uy; 0xb1uy; 0x79uy; 0x0cuy; 0x3fuy;
0xe2uy; 0xeduy; 0x05uy; 0x07uy; 0x72uy; 0xf3uy; 0x89uy; 0x08uy; 0x8cuy; 0x22uy; 0xa7uy; 0x36uy;
0x40uy; 0xcauy; 0x52uy; 0x70uy; 0x1buy; 0x09uy; 0xcbuy; 0xabuy; 0x3buy; 0x64uy; 0x61uy; 0x6duy;
0x5duy; 0xf7uy; 0x15uy; 0x69uy; 0x71uy; 0x3buy; 0x3auy; 0x2euy; 0x53uy; 0x33uy; 0x26uy; 0xe6uy;
0x29uy; 0x5cuy; 0xfbuy; 0x0duy; 0xc6uy; 0xe4uy; 0xbduy; 0x9cuy; 0x43uy; 0xffuy; 0xa6uy; 0x5buy;
0x49uy; 0x47uy; 0x93uy; 0x1cuy; 0x81uy; 0x6fuy; 0xd4uy; 0xaauy; 0x3duy; 0xaduy; 0x86uy; 0xf5uy;
0x94uy; 0x16uy; 0x7fuy; 0x31uy; 0x91uy; 0x30uy; 0x97uy; 0xc4uy; 0xa3uy; 0xe4uy; 0x01uy; 0x2buy;
0x06uy; 0xcfuy; 0x69uy; 0xfbuy; 0x69uy; 0x35uy; 0xaauy; 0x81uy; 0xeduy; 0x90uy; 0x0cuy; 0x3auy;
0xc0uy; 0xa6uy; 0x06uy; 0xabuy; 0x51uy; 0x3fuy; 0x39uy; 0xb2uy; 0x1euy; 0xb0uy; 0x4buy; 0xbcuy;
0xd0uy; 0xd0uy; 0x3auy; 0xdauy; 0x89uy; 0x88uy; 0xa6uy; 0x56uy; 0xd8uy; 0x02uy; 0x98uy; 0xeeuy;
0xa2uy; 0xf5uy; 0x0euy; 0xbauy; 0x7cuy; 0x52uy; 0xafuy; 0xf4uy; 0xbbuy; 0xe7uy; 0x36uy; 0x4auy;
0xdduy; 0x90uy; 0x93uy; 0xe9uy; 0x5duy; 0xbeuy; 0x68uy; 0x99uy; 0xc2uy; 0xaduy; 0x4duy; 0x79uy;
0x25uy; 0x0buy; 0x69uy; 0x79uy; 0x7buy; 0xe2uy; 0x3duy; 0xa8uy; 0xe7uy; 0xf1uy; 0x42uy; 0x0cuy;
0x22uy; 0x85uy; 0x95uy; 0xf0uy; 0xd5uy; 0x5cuy; 0x96uy; 0x35uy; 0xb6uy; 0x19uy; 0xaeuy; 0xb3uy;
0xcfuy; 0x22uy; 0xcauy; 0xbauy; 0x28uy; 0xd6uy; 0xdduy; 0xd5uy; 0x8euy; 0xe8uy; 0xd6uy; 0x90uy;
0x23uy; 0x8euy; 0x97uy; 0x37uy; 0xe9uy; 0xcduy; 0xabuy; 0xdcuy; 0x08uy; 0x04uy; 0xe1uy; 0x32uy;
0x02uy; 0xffuy; 0x7fuy; 0x82uy; 0x41uy; 0xf3uy; 0x9buy; 0x1duy; 0x42uy; 0x8auy; 0x98uy; 0x80uy;
0x81uy; 0xaauy; 0xbeuy; 0x7duy; 0x3buy; 0x83uy; 0x30uy; 0x4duy; 0x4auy; 0x22uy; 0x2duy; 0xafuy;
0x61uy; 0xd1uy; 0xa0uy; 0x66uy; 0xd4uy; 0x48uy; 0x0fuy; 0xe1uy; 0xd9uy; 0x77uy; 0x82uy; 0xc5uy;
0xa1uy; 0x2auy; 0x03uy; 0x1fuy; 0xd0uy; 0x7auy; 0xccuy; 0x77uy; 0x09uy; 0x4auy; 0xbduy; 0xaduy;
0xf7uy; 0x76uy; 0xdcuy; 0x10uy; 0xeduy; 0x5buy; 0xdfuy; 0x89uy; 0xfbuy; 0x52uy; 0x60uy; 0x5cuy;
0x08uy; 0x42uy; 0x50uy; 0xd1uy; 0xdauy; 0x24uy; 0xbbuy; 0x59uy; 0x3euy; 0x14uy; 0xf4uy; 0xf0uy;
0xf4uy; 0xdauy; 0xb8uy; 0x00uy; 0xe2uy; 0x0buy; 0xfauy; 0xc3uy; 0xf6uy; 0x28uy; 0x8duy; 0x20uy;
0x26uy; 0xe9uy; 0x5buy; 0x25uy; 0xa8uy; 0x80uy; 0x4cuy; 0xeeuy; 0xc9uy; 0xb6uy; 0x7auy; 0x8buy;
0x87uy; 0x21uy; 0xfduy; 0xaeuy; 0xd5uy; 0xa8uy; 0x49uy; 0x33uy; 0x58uy; 0x90uy; 0x2cuy; 0x0auy;
0xcauy; 0xb0uy; 0x9duy; 0xbeuy; 0xcduy; 0xe0uy; 0xa4uy; 0x99uy; 0x76uy; 0x01uy; 0x80uy; 0xdduy;
0x66uy; 0x76uy; 0x70uy; 0x05uy; 0xf3uy; 0xd6uy; 0x31uy; 0xa1uy; 0x9euy; 0xd5uy; 0x5fuy; 0x1buy;
0xdduy; 0x7fuy; 0x81uy; 0x6duy; 0x5cuy; 0xe9uy; 0xa3uy; 0x1auy; 0x6auy; 0x87uy; 0x93uy; 0xaduy;
0x1duy; 0x73uy; 0x44uy; 0xbcuy; 0xe4uy; 0x42uy; 0x78uy; 0x6auy; 0x71uy; 0x58uy; 0x9buy; 0x73uy;
0x55uy; 0x63uy; 0xa5uy; 0x32uy; 0xf6uy; 0x55uy; 0x68uy; 0x05uy; 0xcfuy; 0xeduy; 0x5fuy; 0x86uy;
0xe2uy; 0x65uy; 0xefuy; 0xf1uy; 0xb9uy; 0x69uy; 0xbbuy; 0x79uy; 0xb1uy; 0xf4uy; 0x7fuy; 0xa5uy;
0xfauy; 0x62uy; 0xbcuy; 0x68uy; 0xe7uy; 0xf6uy; 0xf8uy; 0xf0uy; 0x55uy; 0xf4uy; 0x93uy; 0x47uy;
0x06uy; 0xf0uy; 0x3euy; 0x94uy; 0x4auy; 0x95uy; 0xc8uy; 0x0cuy; 0xb0uy; 0x04uy; 0x4euy; 0x3fuy;
0x67uy; 0x14uy; 0xeduy; 0xbbuy; 0xbeuy; 0xf0uy; 0xabuy; 0xdduy; 0x6cuy; 0x23uy; 0x4euy; 0x07uy;
0x66uy; 0x41uy; 0x55uy; 0xbeuy; 0x22uy; 0x59uy; 0xd5uy; 0xdauy; 0xd4uy; 0xd8uy; 0x3duy; 0xb0uy;
0x74uy; 0xc4uy; 0x4fuy; 0x9buy; 0x43uy; 0xe5uy; 0x75uy; 0xfbuy; 0x33uy; 0x0euy; 0xdfuy; 0xe1uy;
0xe3uy; 0x7duy; 0x2euy; 0x80uy; 0x10uy; 0x79uy; 0x17uy; 0xeauy; 0xd3uy; 0x18uy; 0x98uy; 0x08uy;
0xeduy; 0x79uy; 0x4cuy; 0xb9uy; 0x66uy; 0x03uy; 0x04uy; 0x50uy; 0xfeuy; 0x62uy; 0x0duy; 0x48uy;
0x1auy; 0x6cuy; 0xeeuy; 0xb7uy; 0x03uy; 0x15uy; 0x92uy; 0x41uy; 0x1euy; 0xa1uy; 0x88uy; 0x46uy;
0x1auy; 0x43uy; 0x49uy; 0xf5uy; 0x93uy; 0x33uy; 0x00uy; 0x65uy; 0x69uy; 0xa8uy; 0x82uy; 0xbduy;
0xbeuy; 0x5cuy; 0x56uy; 0xa3uy; 0x06uy; 0x00uy; 0x8buy; 0x2fuy; 0x7duy; 0xecuy; 0xa4uy; 0x9auy;
0x2auy; 0xaeuy; 0x66uy; 0x07uy; 0x46uy; 0xb3uy; 0xbeuy; 0xf8uy; 0x07uy; 0x08uy; 0x10uy; 0x87uy;
0xd5uy; 0x6cuy; 0x6auy; 0xa5uy; 0xa6uy; 0x07uy; 0x4buy; 0x00uy; 0xc1uy; 0x5auy; 0xeduy; 0x7fuy;
0x14uy; 0x4buy; 0x60uy; 0x02uy; 0xc2uy; 0x67uy; 0x0cuy; 0xa4uy; 0x64uy; 0x54uy; 0x3euy; 0x22uy;
0xfeuy; 0x21uy; 0xcduy; 0x0duy; 0xcbuy; 0x60uy; 0x3buy; 0x13uy; 0xb0uy; 0x8euy; 0x36uy; 0xcauy;
0xcduy; 0x78uy; 0x8duy; 0x08uy; 0x2auy; 0xf1uy; 0x9cuy; 0x17uy; 0x11uy; 0x14uy; 0x57uy; 0x57uy;
0xe8uy; 0x3buy; 0x84uy; 0xe8uy; 0x59uy; 0xdbuy; 0x5buy; 0x77uy; 0x2euy; 0x54uy; 0x3buy; 0x6euy;
0x9cuy; 0x5euy; 0x7fuy; 0x52uy; 0xe5uy; 0x06uy; 0x8auy; 0x2duy; 0xc3uy; 0xbfuy; 0x30uy; 0x34uy;
0x8cuy; 0xaauy; 0x3buy; 0x23uy; 0x59uy; 0x32uy; 0x5fuy; 0xf7uy; 0xc9uy; 0xb2uy; 0xeeuy; 0xb2uy;
0x72uy; 0x75uy; 0x33uy; 0x8euy; 0xa9uy; 0x68uy; 0x6euy; 0xf5uy; 0x61uy; 0x7auy; 0x20uy; 0x01uy;
0xecuy; 0xabuy; 0x19uy; 0x26uy; 0xbeuy; 0x38uy; 0x49uy; 0xe2uy; 0x16uy; 0xceuy; 0x17uy; 0xafuy;
0xcauy; 0xe3uy; 0x06uy; 0xeauy; 0x37uy; 0x98uy; 0xf2uy; 0x8fuy; 0x04uy; 0x9buy; 0xabuy; 0xd8uy;
0xbduy; 0x78uy; 0x68uy; 0xacuy; 0xefuy; 0xb9uy; 0x28uy; 0x6fuy; 0x0buy; 0x37uy; 0x90uy; 0xb3uy;
0x74uy; 0x0cuy; 0x38uy; 0x12uy; 0x70uy; 0xa2uy; 0xbeuy; 0xdcuy; 0xa7uy; 0x18uy; 0xdfuy; 0x5euy;
0xd2uy; 0x62uy; 0xccuy; 0x43uy; 0x24uy; 0x32uy; 0x58uy; 0x45uy; 0x18uy; 0x0auy; 0xe1uy; 0x0duy;
0x82uy; 0xbcuy; 0x08uy; 0xb1uy; 0xa9uy; 0x7euy; 0x63uy; 0x09uy; 0xc6uy; 0x83uy; 0xa1uy; 0xe6uy;
0x5cuy; 0x9cuy; 0xefuy; 0x57uy; 0xecuy; 0xc7uy; 0x73uy; 0x19uy; 0xfbuy; 0x5cuy; 0x20uy; 0xe1uy;
0xdfuy; 0x85uy; 0x76uy; 0xabuy; 0x89uy; 0xb7uy; 0x96uy; 0x8duy; 0xd9uy; 0x8euy; 0xb7uy; 0x00uy;
0xa8uy; 0xc6uy; 0x98uy; 0x47uy; 0x03uy; 0xafuy; 0x56uy; 0x1fuy; 0x35uy; 0x49uy; 0x75uy; 0x4cuy;
0xa2uy; 0xa2uy; 0xdcuy; 0x98uy; 0xbfuy; 0x87uy; 0xeduy; 0x73uy; 0x5fuy; 0x9buy; 0xabuy; 0x3euy;
0x02uy; 0xdcuy; 0xa1uy; 0x4buy; 0x6cuy; 0xacuy; 0x10uy; 0xb2uy; 0x0buy; 0x99uy; 0xeeuy; 0xc8uy;
0xc2uy; 0x82uy; 0xa9uy; 0xf9uy; 0xa9uy; 0xa5uy; 0x4duy; 0xc9uy; 0x39uy; 0x41uy; 0x89uy; 0x0cuy;
0xc6uy; 0xe3uy; 0xaauy; 0x76uy; 0xe7uy; 0x11uy; 0x16uy; 0x8auy; 0x28uy; 0x6buy; 0x22uy; 0x3auy;
0x1euy; 0x7duy; 0xe6uy; 0xf7uy; 0x55uy; 0x85uy; 0x8cuy; 0x36uy; 0x57uy; 0x0buy; 0xdbuy; 0xe6uy;
0xefuy; 0xd9uy; 0xf6uy; 0x94uy; 0x48uy; 0x31uy; 0x7euy; 0xaauy; 0x13uy; 0xd4uy; 0x58uy; 0x9buy;
0xebuy; 0x7cuy; 0x2auy; 0x39uy; 0xdduy; 0xa3uy; 0x3fuy; 0x70uy; 0xfduy; 0x7fuy; 0x30uy; 0xa3uy;
0x34uy; 0xe6uy; 0xacuy; 0x64uy; 0x9buy; 0xf8uy; 0xbbuy; 0x1euy; 0x51uy; 0xe1uy; 0xaduy; 0x61uy;
0xf6uy; 0xffuy; 0xd4uy; 0x4auy; 0x5euy; 0x12uy; 0x40uy; 0xdcuy; 0x07uy; 0x8buy; 0xb2uy; 0xe0uy;
0xb9uy; 0x29uy; 0xaauy; 0x4euy; 0x85uy; 0xf5uy; 0xbduy; 0x5buy; 0x43uy; 0x77uy; 0xc7uy; 0x0buy;
0xfeuy; 0x66uy; 0x49uy; 0xccuy; 0xb5uy; 0x92uy; 0x4auy; 0x14uy; 0x1euy; 0xe2uy; 0xe5uy; 0x20uy;
0xfauy; 0xecuy; 0x0fuy; 0xc9uy
]
let test1_ct_expected =
List.Tot.map u8_from_UInt8
[
0xebuy; 0x01uy; 0x36uy; 0x7duy; 0xe9uy; 0xdauy; 0x51uy; 0x3fuy; 0x8duy; 0xc7uy; 0x53uy; 0xdeuy;
0xfcuy; 0xa2uy; 0x2cuy; 0xacuy; 0x2duy; 0xbcuy; 0x9buy; 0xacuy; 0x9cuy; 0xc0uy; 0xc5uy; 0x08uy;
0x9duy; 0x0duy; 0x07uy; 0xbcuy; 0xd8uy; 0x69uy; 0x20uy; 0xccuy; 0x18uy; 0x0cuy; 0xbcuy; 0x7buy;
0x49uy; 0x23uy; 0x06uy; 0x8cuy; 0x9cuy; 0xc4uy; 0x1fuy; 0xffuy; 0x53uy; 0x91uy; 0x9cuy; 0x7fuy;
0xb4uy; 0xa7uy; 0x28uy; 0xdfuy; 0x30uy; 0x5euy; 0x9euy; 0x19uy; 0xd1uy; 0xbbuy; 0xe7uy; 0xacuy;
0x0cuy; 0xb2uy; 0xbduy; 0x58uy; 0xd6uy; 0x96uy; 0x8buy; 0x04uy; 0x66uy; 0xf6uy; 0xbeuy; 0x58uy;
0x25uy; 0xf9uy; 0xfbuy; 0xe1uy; 0x13uy; 0x7auy; 0x88uy; 0x57uy; 0xb6uy; 0xb5uy; 0x71uy; 0xe6uy;
0xe2uy; 0x63uy; 0xd2uy; 0x85uy; 0x8duy; 0x07uy; 0x37uy; 0xe9uy; 0xaduy; 0xe9uy; 0x3duy; 0x95uy;
0xccuy; 0x7euy; 0x56uy; 0x2duy; 0xaauy; 0x0buy; 0x13uy; 0xdfuy; 0xe8uy; 0x19uy; 0x7euy; 0x52uy;
0x8duy; 0x7buy; 0xaauy; 0x09uy; 0x10uy; 0xb2uy; 0x32uy; 0x9cuy; 0x91uy; 0xf3uy; 0x14uy; 0x49uy;
0x4auy; 0x9fuy; 0x38uy; 0xc0uy; 0xf5uy; 0xf4uy; 0x44uy; 0xc6uy; 0xf6uy; 0xf8uy; 0xd0uy; 0xb0uy;
0x4fuy; 0xc1uy; 0xc3uy; 0xd7uy; 0x71uy; 0x18uy; 0xe3uy; 0xc0uy; 0xf5uy; 0x7auy; 0xd0uy; 0x04uy;
0x4fuy; 0xcfuy; 0x76uy; 0xdcuy; 0xeeuy; 0x35uy; 0x21uy; 0xe0uy; 0x9euy; 0x41uy; 0x10uy; 0x06uy;
0x2duy; 0xb8uy; 0x0cuy; 0xabuy; 0x1duy; 0x3duy; 0x60uy; 0xefuy; 0xaduy; 0xc5uy; 0x80uy; 0x09uy;
0x56uy; 0xeeuy; 0xcbuy; 0x53uy; 0x1buy; 0x50uy; 0x95uy; 0x34uy; 0x47uy; 0xaeuy; 0x70uy; 0x96uy;
0xbauy; 0x19uy; 0x55uy; 0x99uy; 0xd1uy; 0xb1uy; 0xe6uy; 0x32uy; 0xf0uy; 0x19uy; 0x3buy; 0x2buy;
0xc7uy; 0x9cuy; 0xf7uy; 0xcauy; 0xa7uy; 0x3auy; 0xd3uy; 0xdcuy; 0xecuy; 0xf2uy; 0x49uy; 0x43uy;
0x64uy; 0x7cuy; 0xfduy; 0x35uy; 0xe8uy; 0xfauy; 0xa5uy; 0x98uy; 0x01uy; 0x6buy; 0x4euy; 0xe5uy;
0x84uy; 0x03uy; 0x24uy; 0xb6uy; 0xc7uy; 0x30uy; 0x13uy; 0x44uy; 0xd3uy; 0xe6uy; 0x97uy; 0xefuy;
0xf7uy; 0x13uy; 0xefuy; 0x0euy; 0x9fuy; 0x12uy; 0x75uy; 0x76uy; 0x69uy; 0x7cuy; 0x91uy; 0x15uy;
0x6cuy; 0xc0uy; 0xc2uy; 0x60uy; 0x8cuy; 0x63uy; 0xa7uy; 0xfauy; 0xc2uy; 0xf4uy; 0x17uy; 0xbauy;
0x8buy; 0xd4uy; 0xcfuy; 0x4auy; 0x8duy; 0x63uy; 0xb8uy; 0xa4uy; 0x6buy; 0x9cuy; 0x87uy; 0x94uy;
0x37uy; 0x05uy; 0x9duy; 0xc4uy; 0x76uy; 0x24uy; 0x77uy; 0x79uy; 0x4duy; 0x93uy; 0x62uy; 0x0buy;
0xbcuy; 0x72uy; 0x7euy; 0xb2uy; 0xefuy; 0x3cuy; 0x00uy; 0x1cuy; 0x18uy; 0x18uy; 0xbbuy; 0xe8uy;
0x60uy; 0x6euy; 0xc5uy; 0x9buy; 0x47uy; 0x93uy; 0x77uy; 0xd8uy; 0xf0uy; 0x45uy; 0x16uy; 0x97uy;
0x15uy; 0xc0uy; 0xd3uy; 0x4euy; 0x6duy; 0xe9uy; 0xfeuy; 0x89uy; 0xc3uy; 0x87uy; 0x3auy; 0x49uy;
0xfbuy; 0x9duy; 0x86uy; 0xffuy; 0xcauy; 0xa1uy; 0x3fuy; 0x15uy; 0x37uy; 0xd8uy; 0x98uy; 0xeeuy;
0xd9uy; 0x36uy; 0x06uy; 0x33uy; 0xd8uy; 0xdauy; 0x82uy; 0xeeuy; 0x60uy; 0x8cuy; 0xc7uy; 0xf3uy;
0x19uy; 0x47uy; 0x15uy; 0x7fuy; 0xd3uy; 0xf1uy; 0x30uy; 0xa2uy; 0xc6uy; 0xc4uy; 0x04uy; 0x5cuy;
0x50uy; 0xa3uy; 0x48uy; 0xc8uy; 0x1buy; 0x35uy; 0xfeuy; 0xa5uy; 0xeauy; 0x8auy; 0x4auy; 0x8cuy;
0x9cuy; 0x85uy; 0x8cuy; 0x1fuy; 0xbbuy; 0x3duy; 0xafuy; 0x2euy; 0x3auy; 0xaduy; 0x34uy; 0x6cuy;
0x5duy; 0x87uy; 0xc9uy; 0xc9uy; 0x7fuy; 0x30uy; 0xc1uy; 0x8duy; 0x4cuy; 0xd6uy; 0xbfuy; 0xc0uy;
0xf8uy; 0xa7uy; 0xb2uy; 0x91uy; 0x9buy; 0xe7uy; 0x85uy; 0x96uy; 0xe8uy; 0xb3uy; 0xaeuy; 0x89uy;
0x53uy; 0x41uy; 0x48uy; 0x0euy; 0xd0uy; 0x6auy; 0x4euy; 0x0cuy; 0x7duy; 0x10uy; 0xa1uy; 0xe8uy;
0x9duy; 0x7cuy; 0xdcuy; 0x76uy; 0x91uy; 0x86uy; 0x70uy; 0x67uy; 0xe1uy; 0x76uy; 0x4duy; 0x23uy;
0xeauy; 0x55uy; 0x62uy; 0xb9uy; 0x61uy; 0x7fuy; 0x24uy; 0xd3uy; 0x06uy; 0xd8uy; 0x15uy; 0x88uy;
0x52uy; 0x92uy; 0x8auy; 0xc1uy; 0x8auy; 0x1cuy; 0x7buy; 0x40uy; 0xfauy; 0x03uy; 0xe0uy; 0x93uy;
0xf7uy; 0x2duy; 0xf1uy; 0xdcuy; 0x27uy; 0x10uy; 0xd4uy; 0x28uy; 0x0auy; 0x61uy; 0x87uy; 0xbfuy;
0x09uy; 0xfbuy; 0xb1uy; 0xc7uy; 0xd8uy; 0xe9uy; 0xfauy; 0xa5uy; 0xa8uy; 0x6buy; 0x6duy; 0xa0uy;
0x64uy; 0xb7uy; 0xe4uy; 0x86uy; 0x79uy; 0x6euy; 0x85uy; 0x93uy; 0x94uy; 0xc9uy; 0xdeuy; 0xa9uy;
0x40uy; 0xb3uy; 0x6euy; 0xa0uy; 0xa6uy; 0xc8uy; 0xc9uy; 0x84uy; 0x3euy; 0xdbuy; 0x1duy; 0xa8uy;
0xbcuy; 0x04uy; 0x1cuy; 0xa4uy; 0x4fuy; 0x70uy; 0x77uy; 0xafuy; 0x98uy; 0x71uy; 0xc6uy; 0xbeuy;
0x24uy; 0x58uy; 0xc9uy; 0x53uy; 0x20uy; 0xd2uy; 0xeauy; 0x3duy; 0xe7uy; 0x3fuy; 0x8cuy; 0x44uy;
0xc8uy; 0x3fuy; 0x14uy; 0x50uy; 0xcduy; 0xc8uy; 0x45uy; 0x99uy; 0xf8uy; 0xb6uy; 0xd5uy; 0x99uy;
0x5auy; 0x77uy; 0x61uy; 0x48uy; 0x9fuy; 0x1auy; 0xb0uy; 0x6fuy; 0x1cuy; 0x27uy; 0x35uy; 0x80uy;
0xe6uy; 0x1euy; 0xe2uy; 0x75uy; 0xafuy; 0xf8uy; 0x10uy; 0x6duy; 0x0euy; 0xe6uy; 0x8auy; 0xb5uy;
0xffuy; 0x6cuy; 0x1euy; 0x41uy; 0x60uy; 0x93uy; 0xebuy; 0xffuy; 0x9fuy; 0xffuy; 0xf7uy; 0xcauy;
0x77uy; 0x2fuy; 0xc2uy; 0x44uy; 0xe8uy; 0x86uy; 0x23uy; 0x8auy; 0x2euy; 0xa7uy; 0x1buy; 0xb2uy;
0x8auy; 0x6cuy; 0x79uy; 0x0euy; 0x4duy; 0xe2uy; 0x09uy; 0xa7uy; 0xdauy; 0x60uy; 0x54uy; 0x55uy;
0x36uy; 0xb9uy; 0x06uy; 0x51uy; 0xd9uy; 0x1duy; 0x6cuy; 0xaauy; 0x0buy; 0x03uy; 0xb1uy; 0x38uy;
0x63uy; 0xd7uy; 0x29uy; 0x76uy; 0xf6uy; 0xc5uy; 0x73uy; 0x0auy; 0x0euy; 0x1duy; 0xf7uy; 0xc9uy;
0x5auy; 0xdauy; 0xdcuy; 0x64uy; 0xd5uy; 0x9fuy; 0x51uy; 0xc8uy; 0x8euy; 0x6fuy; 0xf6uy; 0xb9uy;
0x0cuy; 0xd4uy; 0x57uy; 0x5duy; 0x82uy; 0x4euy; 0xeeuy; 0xc6uy; 0x8auy; 0xf5uy; 0x7fuy; 0x59uy;
0xe1uy; 0x0cuy; 0xb8uy; 0xe7uy; 0xf6uy; 0xc6uy; 0x2auy; 0xb1uy; 0x5auy; 0xbauy; 0x77uy; 0xa0uy;
0x30uy; 0x19uy; 0x10uy; 0xe6uy; 0x5auy; 0x90uy; 0x03uy; 0x21uy; 0x3euy; 0xd8uy; 0xc1uy; 0xc5uy;
0xc5uy; 0x81uy; 0xf7uy; 0xc1uy; 0x6auy; 0xfauy; 0xecuy; 0xf6uy; 0x31uy; 0x0duy; 0xf6uy; 0x85uy;
0x9fuy; 0xb5uy; 0x34uy; 0x38uy; 0xf8uy; 0xc1uy; 0xe6uy; 0x7euy; 0x67uy; 0x8buy; 0x14uy; 0x01uy;
0x3buy; 0x32uy; 0xb6uy; 0xb1uy; 0x90uy; 0x91uy; 0xbcuy; 0x40uy; 0x90uy; 0x72uy; 0x55uy; 0x76uy;
0x2buy; 0x34uy; 0x3buy; 0x05uy; 0x65uy; 0x87uy; 0x0euy; 0x4buy; 0xb5uy; 0xcduy; 0x94uy; 0x88uy;
0x60uy; 0xf0uy; 0x7duy; 0xc9uy; 0x21uy; 0x71uy; 0xe2uy; 0x55uy; 0x43uy; 0x06uy; 0x1cuy; 0x84uy;
0x02uy; 0xd0uy; 0x4euy; 0xcbuy; 0x1buy; 0x38uy; 0x6duy; 0x58uy; 0x62uy; 0xabuy; 0x50uy; 0xcfuy;
0xb5uy; 0x47uy; 0x24uy; 0xb8uy; 0x6cuy; 0x00uy; 0xa4uy; 0xf2uy; 0x97uy; 0x9fuy; 0xf3uy; 0x98uy;
0x2euy; 0xf9uy; 0x4fuy; 0x02uy; 0xdcuy; 0x1duy; 0xc6uy; 0x08uy; 0x35uy; 0x57uy; 0xe5uy; 0x9buy;
0xd7uy; 0xf4uy; 0xd7uy; 0x28uy; 0x50uy; 0x39uy; 0xfduy; 0xd8uy; 0xe6uy; 0xbfuy; 0xcauy; 0x61uy;
0x65uy; 0xe3uy; 0xd0uy; 0x95uy; 0x65uy; 0x68uy; 0xb1uy; 0x41uy; 0x65uy; 0x1auy; 0x62uy; 0xceuy;
0x65uy; 0x8fuy; 0xeeuy; 0xe7uy; 0x7auy; 0x3cuy; 0x04uy; 0x95uy; 0x01uy; 0xd1uy; 0x31uy; 0x75uy;
0x80uy; 0x69uy; 0x1euy; 0x4buy; 0xb3uy; 0x4fuy; 0xb9uy; 0x5buy; 0x5cuy; 0x8euy; 0x16uy; 0x01uy;
0x99uy; 0x02uy; 0x55uy; 0x94uy; 0x0buy; 0xa9uy; 0x49uy; 0x7cuy; 0x10uy; 0xd4uy; 0xc9uy; 0xdduy;
0x2buy; 0xabuy; 0x8buy; 0x4cuy; 0x21uy; 0x7auy; 0x7duy; 0x53uy; 0x7buy; 0xd0uy; 0x69uy; 0x45uy;
0xcauy; 0x9auy; 0x91uy; 0x40uy; 0x54uy; 0x03uy; 0xb3uy; 0x56uy; 0x0euy; 0xc6uy; 0x68uy; 0x30uy;
0xdcuy; 0xb1uy; 0xffuy; 0xe4uy; 0x3fuy; 0x0euy; 0x1euy; 0xc0uy; 0x56uy; 0xb2uy; 0xe1uy; 0xfcuy;
0x58uy; 0xf5uy; 0xabuy; 0x39uy; 0x4euy; 0xdduy; 0x33uy; 0xbcuy; 0x12uy; 0xc5uy; 0xdcuy; 0x77uy;
0x46uy; 0x84uy; 0x82uy; 0xb2uy; 0x7fuy; 0xa2uy; 0xf6uy; 0x06uy; 0x24uy; 0xd6uy; 0x3cuy; 0xe3uy;
0xc5uy; 0xc2uy; 0x18uy; 0xc4uy; 0xc9uy; 0xf5uy; 0xa3uy; 0x2auy; 0x56uy; 0x5buy; 0x59uy; 0xe7uy;
0x00uy; 0x92uy; 0xb4uy; 0xd6uy; 0xf9uy; 0x96uy; 0x7cuy; 0x01uy; 0x26uy; 0x1euy; 0x5fuy; 0x27uy;
0x9cuy; 0x1buy; 0xb7uy; 0xf7uy; 0x36uy; 0xebuy; 0x7auy; 0xf3uy; 0xa7uy; 0x5euy; 0x38uy; 0xb2uy;
0x7buy; 0x7fuy; 0xd1uy; 0x4euy; 0x68uy; 0xb9uy; 0xa9uy; 0xf8uy; 0x7auy; 0x06uy; 0xb4uy; 0xe8uy;
0x42uy; 0xd8uy; 0xc7uy; 0x5auy; 0x08uy; 0xd5uy; 0x67uy; 0xa7uy; 0x30uy; 0xb6uy; 0x2euy; 0x80uy;
0xacuy; 0xa9uy; 0x07uy; 0xbbuy; 0x18uy; 0x54uy; 0xc3uy; 0x81uy; 0x6euy; 0x8auy; 0x24uy; 0xc0uy;
0x7fuy; 0xd0uy; 0x54uy; 0xb2uy; 0xe7uy; 0x1auy; 0x11uy; 0xf4uy; 0x9duy; 0x2cuy; 0x75uy; 0x37uy;
0x2euy; 0xc6uy; 0xfcuy; 0x85uy; 0x5duy; 0x46uy; 0x44uy; 0x7auy; 0x36uy; 0xe5uy; 0x62uy; 0xa4uy;
0x26uy; 0xdduy; 0x4cuy; 0x20uy; 0x33uy; 0x7auy; 0x8auy; 0x41uy; 0x8auy; 0x0fuy; 0xa4uy; 0xf8uy;
0x74uy; 0x45uy; 0x98uy; 0xe3uy; 0x73uy; 0xa1uy; 0x4euy; 0x40uy; 0x10uy; 0x5buy; 0x0fuy; 0xa0uy;
0xe4uy; 0x5euy; 0x97uy; 0x40uy; 0xdcuy; 0x68uy; 0x79uy; 0xd7uy; 0xfeuy; 0xfduy; 0x34uy; 0xd0uy;
0xb7uy; 0xcbuy; 0x4auy; 0xf3uy; 0xb0uy; 0xc7uy; 0xf5uy; 0xbauy; 0x6cuy; 0xa9uy; 0xf0uy; 0x82uy;
0x01uy; 0xb2uy; 0x3fuy; 0x9euy; 0x56uy; 0x9cuy; 0x86uy; 0x05uy; 0x03uy; 0x99uy; 0x2euy; 0xe7uy;
0xeduy; 0xdfuy; 0xfeuy; 0x05uy; 0x3buy; 0xdbuy; 0x3cuy; 0x30uy; 0x98uy; 0xa2uy; 0x23uy; 0x86uy;
0xefuy; 0x80uy; 0xe4uy; 0x2fuy; 0xdeuy; 0x8cuy; 0x7duy; 0x2euy; 0x78uy; 0xdbuy; 0xd6uy; 0xcauy;
0x7fuy; 0x79uy; 0x7auy; 0x3buy; 0xafuy; 0x2auy; 0xeduy; 0xf3uy; 0x03uy; 0x15uy; 0xccuy; 0x3duy;
0x52uy; 0x50uy; 0x1duy; 0x08uy; 0x93uy; 0xa2uy; 0xd8uy; 0x63uy; 0x91uy; 0xa0uy; 0x6cuy; 0xccuy
]
let test1_sk_expected =
List.Tot.map u8_from_UInt8
[
0xa6uy; 0x65uy; 0x65uy; 0x9fuy; 0xfbuy; 0xe4uy; 0x06uy; 0x5cuy; 0xcauy; 0x81uy; 0x5auy; 0x45uy;
0xe4uy; 0x94uy; 0xd8uy; 0x01uy; 0x0duy; 0xacuy; 0x6fuy; 0x83uy; 0x94uy; 0x00uy; 0x1auy; 0xcauy;
0x97uy; 0xa1uy; 0xaauy; 0x42uy; 0x80uy; 0x9duy; 0x6buy; 0xa5uy; 0xfcuy; 0x64uy; 0x43uy; 0xdbuy;
0xbeuy; 0x6fuy; 0x12uy; 0x2auy; 0x94uy; 0x58uy; 0x36uy; 0xf2uy; 0xb1uy; 0xf8uy; 0xe5uy; 0xf0uy;
0x57uy; 0x4buy; 0x35uy; 0x51uy; 0xdduy; 0x8cuy; 0x36uy; 0x28uy; 0x34uy; 0x46uy; 0xd6uy; 0xafuy;
0x5duy; 0x49uy; 0x0euy; 0x27uy; 0xd8uy; 0xd3uy; 0xaduy; 0xe1uy; 0xeduy; 0x8buy; 0x2duy; 0x13uy;
0xf5uy; 0x5auy; 0xb6uy; 0xdduy; 0xc0uy; 0x54uy; 0x76uy; 0x09uy; 0xa6uy; 0xa4uy; 0x01uy; 0xb9uy;
0xb7uy; 0xd1uy; 0x26uy; 0xd5uy; 0x1euy; 0xa8uy; 0x20uy; 0x4duy; 0xe8uy; 0xefuy; 0xaduy; 0xb9uy;
0xf0uy; 0x65uy; 0xe9uy; 0xc4uy; 0xf4uy; 0x11uy; 0x98uy; 0x99uy; 0xf0uy; 0x2cuy; 0x63uy; 0x7buy;
0x98uy; 0xd7uy; 0x60uy; 0x43uy; 0x5duy; 0x8cuy; 0x85uy; 0xe9uy; 0xc5uy; 0x83uy; 0x83uy; 0x62uy;
0xe2uy; 0x13uy; 0x33uy; 0x54uy; 0x4buy; 0x71uy; 0xaeuy; 0x63uy; 0xbauy; 0x5auy; 0x4euy; 0x32uy;
0x59uy; 0x78uy; 0x6buy; 0x4duy; 0x39uy; 0xcfuy; 0xe1uy; 0x82uy; 0x58uy; 0x0auy; 0xc3uy; 0x61uy;
0x6auy; 0x89uy; 0x2fuy; 0x1buy; 0x70uy; 0xdduy; 0x16uy; 0x3euy; 0x96uy; 0xb1uy; 0x4cuy; 0x71uy;
0xb1uy; 0x79uy; 0x0cuy; 0x3fuy; 0xe2uy; 0xeduy; 0x05uy; 0x07uy; 0x72uy; 0xf3uy; 0x89uy; 0x08uy;
0x8cuy; 0x22uy; 0xa7uy; 0x36uy; 0x40uy; 0xcauy; 0x52uy; 0x70uy; 0x1buy; 0x09uy; 0xcbuy; 0xabuy;
0x3buy; 0x64uy; 0x61uy; 0x6duy; 0x5duy; 0xf7uy; 0x15uy; 0x69uy; 0x71uy; 0x3buy; 0x3auy; 0x2euy;
0x53uy; 0x33uy; 0x26uy; 0xe6uy; 0x29uy; 0x5cuy; 0xfbuy; 0x0duy; 0xc6uy; 0xe4uy; 0xbduy; 0x9cuy;
0x43uy; 0xffuy; 0xa6uy; 0x5buy; 0x49uy; 0x47uy; 0x93uy; 0x1cuy; 0x81uy; 0x6fuy; 0xd4uy; 0xaauy;
0x3duy; 0xaduy; 0x86uy; 0xf5uy; 0x94uy; 0x16uy; 0x7fuy; 0x31uy; 0x91uy; 0x30uy; 0x97uy; 0xc4uy;
0xa3uy; 0xe4uy; 0x01uy; 0x2buy; 0x06uy; 0xcfuy; 0x69uy; 0xfbuy; 0x69uy; 0x35uy; 0xaauy; 0x81uy;
0xeduy; 0x90uy; 0x0cuy; 0x3auy; 0xc0uy; 0xa6uy; 0x06uy; 0xabuy; 0x51uy; 0x3fuy; 0x39uy; 0xb2uy;
0x1euy; 0xb0uy; 0x4buy; 0xbcuy; 0xd0uy; 0xd0uy; 0x3auy; 0xdauy; 0x89uy; 0x88uy; 0xa6uy; 0x56uy;
0xd8uy; 0x02uy; 0x98uy; 0xeeuy; 0xa2uy; 0xf5uy; 0x0euy; 0xbauy; 0x7cuy; 0x52uy; 0xafuy; 0xf4uy;
0xbbuy; 0xe7uy; 0x36uy; 0x4auy; 0xdduy; 0x90uy; 0x93uy; 0xe9uy; 0x5duy; 0xbeuy; 0x68uy; 0x99uy;
0xc2uy; 0xaduy; 0x4duy; 0x79uy; 0x25uy; 0x0buy; 0x69uy; 0x79uy; 0x7buy; 0xe2uy; 0x3duy; 0xa8uy;
0xe7uy; 0xf1uy; 0x42uy; 0x0cuy; 0x22uy; 0x85uy; 0x95uy; 0xf0uy; 0xd5uy; 0x5cuy; 0x96uy; 0x35uy;
0xb6uy; 0x19uy; 0xaeuy; 0xb3uy; 0xcfuy; 0x22uy; 0xcauy; 0xbauy; 0x28uy; 0xd6uy; 0xdduy; 0xd5uy;
0x8euy; 0xe8uy; 0xd6uy; 0x90uy; 0x23uy; 0x8euy; 0x97uy; 0x37uy; 0xe9uy; 0xcduy; 0xabuy; 0xdcuy;
0x08uy; 0x04uy; 0xe1uy; 0x32uy; 0x02uy; 0xffuy; 0x7fuy; 0x82uy; 0x41uy; 0xf3uy; 0x9buy; 0x1duy;
0x42uy; 0x8auy; 0x98uy; 0x80uy; 0x81uy; 0xaauy; 0xbeuy; 0x7duy; 0x3buy; 0x83uy; 0x30uy; 0x4duy;
0x4auy; 0x22uy; 0x2duy; 0xafuy; 0x61uy; 0xd1uy; 0xa0uy; 0x66uy; 0xd4uy; 0x48uy; 0x0fuy; 0xe1uy;
0xd9uy; 0x77uy; 0x82uy; 0xc5uy; 0xa1uy; 0x2auy; 0x03uy; 0x1fuy; 0xd0uy; 0x7auy; 0xccuy; 0x77uy;
0x09uy; 0x4auy; 0xbduy; 0xaduy; 0xf7uy; 0x76uy; 0xdcuy; 0x10uy; 0xeduy; 0x5buy; 0xdfuy; 0x89uy;
0xfbuy; 0x52uy; 0x60uy; 0x5cuy; 0x08uy; 0x42uy; 0x50uy; 0xd1uy; 0xdauy; 0x24uy; 0xbbuy; 0x59uy;
0x3euy; 0x14uy; 0xf4uy; 0xf0uy; 0xf4uy; 0xdauy; 0xb8uy; 0x00uy; 0xe2uy; 0x0buy; 0xfauy; 0xc3uy;
0xf6uy; 0x28uy; 0x8duy; 0x20uy; 0x26uy; 0xe9uy; 0x5buy; 0x25uy; 0xa8uy; 0x80uy; 0x4cuy; 0xeeuy;
0xc9uy; 0xb6uy; 0x7auy; 0x8buy; 0x87uy; 0x21uy; 0xfduy; 0xaeuy; 0xd5uy; 0xa8uy; 0x49uy; 0x33uy;
0x58uy; 0x90uy; 0x2cuy; 0x0auy; 0xcauy; 0xb0uy; 0x9duy; 0xbeuy; 0xcduy; 0xe0uy; 0xa4uy; 0x99uy;
0x76uy; 0x01uy; 0x80uy; 0xdduy; 0x66uy; 0x76uy; 0x70uy; 0x05uy; 0xf3uy; 0xd6uy; 0x31uy; 0xa1uy;
0x9euy; 0xd5uy; 0x5fuy; 0x1buy; 0xdduy; 0x7fuy; 0x81uy; 0x6duy; 0x5cuy; 0xe9uy; 0xa3uy; 0x1auy;
0x6auy; 0x87uy; 0x93uy; 0xaduy; 0x1duy; 0x73uy; 0x44uy; 0xbcuy; 0xe4uy; 0x42uy; 0x78uy; 0x6auy;
0x71uy; 0x58uy; 0x9buy; 0x73uy; 0x55uy; 0x63uy; 0xa5uy; 0x32uy; 0xf6uy; 0x55uy; 0x68uy; 0x05uy;
0xcfuy; 0xeduy; 0x5fuy; 0x86uy; 0xe2uy; 0x65uy; 0xefuy; 0xf1uy; 0xb9uy; 0x69uy; 0xbbuy; 0x79uy;
0xb1uy; 0xf4uy; 0x7fuy; 0xa5uy; 0xfauy; 0x62uy; 0xbcuy; 0x68uy; 0xe7uy; 0xf6uy; 0xf8uy; 0xf0uy;
0x55uy; 0xf4uy; 0x93uy; 0x47uy; 0x06uy; 0xf0uy; 0x3euy; 0x94uy; 0x4auy; 0x95uy; 0xc8uy; 0x0cuy;
0xb0uy; 0x04uy; 0x4euy; 0x3fuy; 0x67uy; 0x14uy; 0xeduy; 0xbbuy; 0xbeuy; 0xf0uy; 0xabuy; 0xdduy;
0x6cuy; 0x23uy; 0x4euy; 0x07uy; 0x66uy; 0x41uy; 0x55uy; 0xbeuy; 0x22uy; 0x59uy; 0xd5uy; 0xdauy;
0xd4uy; 0xd8uy; 0x3duy; 0xb0uy; 0x74uy; 0xc4uy; 0x4fuy; 0x9buy; 0x43uy; 0xe5uy; 0x75uy; 0xfbuy;
0x33uy; 0x0euy; 0xdfuy; 0xe1uy; 0xe3uy; 0x7duy; 0x2euy; 0x80uy; 0x10uy; 0x79uy; 0x17uy; 0xeauy;
0xd3uy; 0x18uy; 0x98uy; 0x08uy; 0xeduy; 0x79uy; 0x4cuy; 0xb9uy; 0x66uy; 0x03uy; 0x04uy; 0x50uy;
0xfeuy; 0x62uy; 0x0duy; 0x48uy; 0x1auy; 0x6cuy; 0xeeuy; 0xb7uy; 0x03uy; 0x15uy; 0x92uy; 0x41uy;
0x1euy; 0xa1uy; 0x88uy; 0x46uy; 0x1auy; 0x43uy; 0x49uy; 0xf5uy; 0x93uy; 0x33uy; 0x00uy; 0x65uy;
0x69uy; 0xa8uy; 0x82uy; 0xbduy; 0xbeuy; 0x5cuy; 0x56uy; 0xa3uy; 0x06uy; 0x00uy; 0x8buy; 0x2fuy;
0x7duy; 0xecuy; 0xa4uy; 0x9auy; 0x2auy; 0xaeuy; 0x66uy; 0x07uy; 0x46uy; 0xb3uy; 0xbeuy; 0xf8uy;
0x07uy; 0x08uy; 0x10uy; 0x87uy; 0xd5uy; 0x6cuy; 0x6auy; 0xa5uy; 0xa6uy; 0x07uy; 0x4buy; 0x00uy;
0xc1uy; 0x5auy; 0xeduy; 0x7fuy; 0x14uy; 0x4buy; 0x60uy; 0x02uy; 0xc2uy; 0x67uy; 0x0cuy; 0xa4uy;
0x64uy; 0x54uy; 0x3euy; 0x22uy; 0xfeuy; 0x21uy; 0xcduy; 0x0duy; 0xcbuy; 0x60uy; 0x3buy; 0x13uy;
0xb0uy; 0x8euy; 0x36uy; 0xcauy; 0xcduy; 0x78uy; 0x8duy; 0x08uy; 0x2auy; 0xf1uy; 0x9cuy; 0x17uy;
0x11uy; 0x14uy; 0x57uy; 0x57uy; 0xe8uy; 0x3buy; 0x84uy; 0xe8uy; 0x59uy; 0xdbuy; 0x5buy; 0x77uy;
0x2euy; 0x54uy; 0x3buy; 0x6euy; 0x9cuy; 0x5euy; 0x7fuy; 0x52uy; 0xe5uy; 0x06uy; 0x8auy; 0x2duy;
0xc3uy; 0xbfuy; 0x30uy; 0x34uy; 0x8cuy; 0xaauy; 0x3buy; 0x23uy; 0x59uy; 0x32uy; 0x5fuy; 0xf7uy;
0xc9uy; 0xb2uy; 0xeeuy; 0xb2uy; 0x72uy; 0x75uy; 0x33uy; 0x8euy; 0xa9uy; 0x68uy; 0x6euy; 0xf5uy;
0x61uy; 0x7auy; 0x20uy; 0x01uy; 0xecuy; 0xabuy; 0x19uy; 0x26uy; 0xbeuy; 0x38uy; 0x49uy; 0xe2uy;
0x16uy; 0xceuy; 0x17uy; 0xafuy; 0xcauy; 0xe3uy; 0x06uy; 0xeauy; 0x37uy; 0x98uy; 0xf2uy; 0x8fuy;
0x04uy; 0x9buy; 0xabuy; 0xd8uy; 0xbduy; 0x78uy; 0x68uy; 0xacuy; 0xefuy; 0xb9uy; 0x28uy; 0x6fuy;
0x0buy; 0x37uy; 0x90uy; 0xb3uy; 0x74uy; 0x0cuy; 0x38uy; 0x12uy; 0x70uy; 0xa2uy; 0xbeuy; 0xdcuy;
0xa7uy; 0x18uy; 0xdfuy; 0x5euy; 0xd2uy; 0x62uy; 0xccuy; 0x43uy; 0x24uy; 0x32uy; 0x58uy; 0x45uy;
0x18uy; 0x0auy; 0xe1uy; 0x0duy; 0x82uy; 0xbcuy; 0x08uy; 0xb1uy; 0xa9uy; 0x7euy; 0x63uy; 0x09uy;
0xc6uy; 0x83uy; 0xa1uy; 0xe6uy; 0x5cuy; 0x9cuy; 0xefuy; 0x57uy; 0xecuy; 0xc7uy; 0x73uy; 0x19uy;
0xfbuy; 0x5cuy; 0x20uy; 0xe1uy; 0xdfuy; 0x85uy; 0x76uy; 0xabuy; 0x89uy; 0xb7uy; 0x96uy; 0x8duy;
0xd9uy; 0x8euy; 0xb7uy; 0x00uy; 0xa8uy; 0xc6uy; 0x98uy; 0x47uy; 0x03uy; 0xafuy; 0x56uy; 0x1fuy;
0x35uy; 0x49uy; 0x75uy; 0x4cuy; 0xa2uy; 0xa2uy; 0xdcuy; 0x98uy; 0xbfuy; 0x87uy; 0xeduy; 0x73uy;
0x5fuy; 0x9buy; 0xabuy; 0x3euy; 0x02uy; 0xdcuy; 0xa1uy; 0x4buy; 0x6cuy; 0xacuy; 0x10uy; 0xb2uy;
0x0buy; 0x99uy; 0xeeuy; 0xc8uy; 0xc2uy; 0x82uy; 0xa9uy; 0xf9uy; 0xa9uy; 0xa5uy; 0x4duy; 0xc9uy;
0x39uy; 0x41uy; 0x89uy; 0x0cuy; 0xc6uy; 0xe3uy; 0xaauy; 0x76uy; 0xe7uy; 0x11uy; 0x16uy; 0x8auy;
0x28uy; 0x6buy; 0x22uy; 0x3auy; 0x1euy; 0x7duy; 0xe6uy; 0xf7uy; 0x55uy; 0x85uy; 0x8cuy; 0x36uy;
0x57uy; 0x0buy; 0xdbuy; 0xe6uy; 0xefuy; 0xd9uy; 0xf6uy; 0x94uy; 0x48uy; 0x31uy; 0x7euy; 0xaauy;
0x13uy; 0xd4uy; 0x58uy; 0x9buy; 0xebuy; 0x7cuy; 0x2auy; 0x39uy; 0xdduy; 0xa3uy; 0x3fuy; 0x70uy;
0xfduy; 0x7fuy; 0x30uy; 0xa3uy; 0x34uy; 0xe6uy; 0xacuy; 0x64uy; 0x9buy; 0xf8uy; 0xbbuy; 0x1euy;
0x51uy; 0xe1uy; 0xaduy; 0x61uy; 0xf6uy; 0xffuy; 0xd4uy; 0x4auy; 0x5euy; 0x12uy; 0x40uy; 0xdcuy;
0x07uy; 0x8buy; 0xb2uy; 0xe0uy; 0xb9uy; 0x29uy; 0xaauy; 0x4euy; 0x85uy; 0xf5uy; 0xbduy; 0x5buy;
0x43uy; 0x77uy; 0xc7uy; 0x0buy; 0xfeuy; 0x66uy; 0x49uy; 0xccuy; 0xb5uy; 0x92uy; 0x4auy; 0x14uy;
0x1euy; 0xe2uy; 0xe5uy; 0x20uy; 0xfauy; 0xecuy; 0x0fuy; 0xc9uy; 0x02uy; 0x00uy; 0xffuy; 0xffuy;
0xfeuy; 0xffuy; 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0xfduy; 0xffuy; 0x02uy; 0x00uy; 0x05uy; 0x00uy;
0x04uy; 0x00uy; 0xfauy; 0xffuy; 0xffuy; 0xffuy; 0x02uy; 0x00uy; 0xfduy; 0xffuy; 0xfduy; 0xffuy;
0x00uy; 0x00uy; 0x01uy; 0x00uy; 0x03uy; 0x00uy; 0xffuy; 0xffuy; 0x00uy; 0x00uy; 0xfbuy; 0xffuy;
0xfeuy; 0xffuy; 0xfeuy; 0xffuy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0x00uy; 0x00uy; 0xffuy; 0xffuy;
0xfauy; 0xffuy; 0xfduy; 0xffuy; 0x04uy; 0x00uy; 0xffuy; 0xffuy; 0x05uy; 0x00uy; 0x05uy; 0x00uy;
0xfeuy; 0xffuy; 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xfduy; 0xffuy; 0x02uy; 0x00uy;
0xffuy; 0xffuy; 0xfduy; 0xffuy; 0x01uy; 0x00uy; 0xfeuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy;
0x06uy; 0x00uy; 0xffuy; 0xffuy; 0x03uy; 0x00uy; 0x03uy; 0x00uy; 0xfduy; 0xffuy; 0x04uy; 0x00uy;
0x01uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0x07uy; 0x00uy; 0xfcuy; 0xffuy; 0x05uy; 0x00uy;
0x04uy; 0x00uy; 0x04uy; 0x00uy; 0xfeuy; 0xffuy; 0xfduy; 0xffuy; 0xfeuy; 0xffuy; 0xfduy; 0xffuy;
0xfeuy; 0xffuy; 0xfeuy; 0xffuy; 0x00uy; 0x00uy; 0x03uy; 0x00uy; 0x02uy; 0x00uy; 0x02uy; 0x00uy;
0x03uy; 0x00uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0xfeuy; 0xffuy; 0xfeuy; 0xffuy; 0x06uy; 0x00uy;
0x02uy; 0x00uy; 0xffuy; 0xffuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x01uy; 0x00uy; 0xffuy; 0xffuy;
0x04uy; 0x00uy; 0xffuy; 0xffuy; 0x03uy; 0x00uy; 0xfduy; 0xffuy; 0xfduy; 0xffuy; 0xffuy; 0xffuy;
0x03uy; 0x00uy; 0xfduy; 0xffuy; 0xfduy; 0xffuy; 0x03uy; 0x00uy; 0x04uy; 0x00uy; 0x03uy; 0x00uy;
0xfduy; 0xffuy; 0x02uy; 0x00uy; 0x01uy; 0x00uy; 0x02uy; 0x00uy; 0xffuy; 0xffuy; 0x04uy; 0x00uy;
0xfeuy; 0xffuy; 0xffuy; 0xffuy; 0xfcuy; 0xffuy; 0xfeuy; 0xffuy; 0xfeuy; 0xffuy; 0x00uy; 0x00uy;
0xfduy; 0xffuy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0x02uy; 0x00uy;
0x00uy; 0x00uy; 0xffuy; 0xffuy; 0x01uy; 0x00uy; 0xfeuy; 0xffuy; 0x00uy; 0x00uy; 0xfduy; 0xffuy;
0xffuy; 0xffuy; 0x01uy; 0x00uy; 0x02uy; 0x00uy; 0xfbuy; 0xffuy; 0x03uy; 0x00uy; 0xfcuy; 0xffuy;
0x04uy; 0x00uy; 0xfbuy; 0xffuy; 0xffuy; 0xffuy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy;
0x02uy; 0x00uy; 0x04uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0x00uy; 0x00uy; 0x02uy; 0x00uy;
0xffuy; 0xffuy; 0xfcuy; 0xffuy; 0x06uy; 0x00uy; 0x02uy; 0x00uy; 0x03uy; 0x00uy; 0xfeuy; 0xffuy;
0xffuy; 0xffuy; 0xfduy; 0xffuy; 0xfeuy; 0xffuy; 0x02uy; 0x00uy; 0xfeuy; 0xffuy; 0x04uy; 0x00uy;
0x04uy; 0x00uy; 0xfcuy; 0xffuy; 0xfcuy; 0xffuy; 0x02uy; 0x00uy; 0x05uy; 0x00uy; 0x01uy; 0x00uy;
0x00uy; 0x00uy; 0x01uy; 0x00uy; 0xfauy; 0xffuy; 0x00uy; 0x00uy; 0x02uy; 0x00uy; 0x02uy; 0x00uy;
0x01uy; 0x00uy; 0xfeuy; 0xffuy; 0x04uy; 0x00uy; 0x00uy; 0x00uy; 0x01uy; 0x00uy; 0x07uy; 0x00uy;
0x04uy; 0x00uy; 0x03uy; 0x00uy; 0x01uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0x01uy; 0x00uy;
0xfeuy; 0xffuy; 0xfduy; 0xffuy; 0x04uy; 0x00uy; 0x01uy; 0x00uy; 0x03uy; 0x00uy; 0xffuy; 0xffuy;
0x02uy; 0x00uy; 0xfcuy; 0xffuy; 0x02uy; 0x00uy; 0xfcuy; 0xffuy; 0x02uy; 0x00uy; 0xffuy; 0xffuy;
0x02uy; 0x00uy; 0xffuy; 0xffuy; 0x00uy; 0x00uy; 0x01uy; 0x00uy; 0xfbuy; 0xffuy; 0x04uy; 0x00uy;
0x02uy; 0x00uy; 0xfduy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0x00uy; 0x00uy; 0x01uy; 0x00uy;
0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xfeuy; 0xffuy; 0x01uy; 0x00uy; 0x01uy; 0x00uy; 0xffuy; 0xffuy;
0x03uy; 0x00uy; 0xfcuy; 0xffuy; 0xfduy; 0xffuy; 0x01uy; 0x00uy; 0x02uy; 0x00uy; 0x03uy; 0x00uy;
0xffuy; 0xffuy; 0x04uy; 0x00uy; 0x00uy; 0x00uy; 0x01uy; 0x00uy; 0x04uy; 0x00uy; 0x01uy; 0x00uy;
0xfeuy; 0xffuy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0x02uy; 0x00uy;
0x00uy; 0x00uy; 0x04uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0x08uy; 0x00uy; 0xfduy; 0xffuy;
0x03uy; 0x00uy; 0xfcuy; 0xffuy; 0x02uy; 0x00uy; 0x02uy; 0x00uy; 0xffuy; 0xffuy; 0xfbuy; 0xffuy;
0x00uy; 0x00uy; 0xfbuy; 0xffuy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0x04uy; 0x00uy; 0x01uy; 0x00uy;
0x03uy; 0x00uy; 0x01uy; 0x00uy; 0xfduy; 0xffuy; 0x02uy; 0x00uy; 0xfeuy; 0xffuy; 0xffuy; 0xffuy;
0x01uy; 0x00uy; 0xfcuy; 0xffuy; 0xfeuy; 0xffuy; 0x01uy; 0x00uy; 0xfcuy; 0xffuy; 0xfauy; 0xffuy;
0xfauy; 0xffuy; 0xfcuy; 0xffuy; 0xfbuy; 0xffuy; 0xfeuy; 0xffuy; 0xffuy; 0xffuy; 0xfduy; 0xffuy;
0x01uy; 0x00uy; 0x05uy; 0x00uy; 0xfbuy; 0xffuy; 0xfduy; 0xffuy; 0xfcuy; 0xffuy; 0x05uy; 0x00uy;
0xfduy; 0xffuy; 0xfbuy; 0xffuy; 0xfduy; 0xffuy; 0xfbuy; 0xffuy; 0x03uy; 0x00uy; 0x03uy; 0x00uy;
0xfcuy; 0xffuy; 0xfduy; 0xffuy; 0x02uy; 0x00uy; 0x01uy; 0x00uy; 0x02uy; 0x00uy; 0x01uy; 0x00uy;
0x00uy; 0x00uy; 0xfeuy; 0xffuy; 0xfeuy; 0xffuy; 0xfbuy; 0xffuy; 0xfeuy; 0xffuy; 0xfeuy; 0xffuy;
0xfeuy; 0xffuy; 0x01uy; 0x00uy; 0x02uy; 0x00uy; 0x02uy; 0x00uy; 0xfduy; 0xffuy; 0xfeuy; 0xffuy;
0xfeuy; 0xffuy; 0x02uy; 0x00uy; 0xfduy; 0xffuy; 0x04uy; 0x00uy; 0x00uy; 0x00uy; 0x01uy; 0x00uy;
0x01uy; 0x00uy; 0xffuy; 0xffuy; 0x02uy; 0x00uy; 0xfeuy; 0xffuy; 0x06uy; 0x00uy; 0x04uy; 0x00uy;
0xfauy; 0xffuy; 0xfeuy; 0xffuy; 0x00uy; 0x00uy; 0x02uy; 0x00uy; 0x05uy; 0x00uy; 0xffuy; 0xffuy;
0x00uy; 0x00uy; 0x01uy; 0x00uy; 0xfeuy; 0xffuy; 0x04uy; 0x00uy; 0xfcuy; 0xffuy; 0xfduy; 0xffuy;
0xfduy; 0xffuy; 0x01uy; 0x00uy; 0xfeuy; 0xffuy; 0xffuy; 0xffuy; 0x00uy; 0x00uy; 0xfduy; 0xffuy;
0xfeuy; 0xffuy; 0x01uy; 0x00uy; 0xfeuy; 0xffuy; 0x01uy; 0x00uy; 0xfeuy; 0xffuy; 0x00uy; 0x00uy;
0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x02uy; 0x00uy; 0x01uy; 0x00uy; 0x01uy; 0x00uy; 0xfcuy; 0xffuy;
0x03uy; 0x00uy; 0x08uy; 0x00uy; 0x00uy; 0x00uy; 0x01uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy;
0xffuy; 0xffuy; 0x00uy; 0x00uy; 0x01uy; 0x00uy; 0x06uy; 0x00uy; 0xfeuy; 0xffuy; 0x02uy; 0x00uy;
0x09uy; 0x00uy; 0xffuy; 0xffuy; 0xfeuy; 0xffuy; 0x01uy; 0x00uy; 0xfauy; 0xffuy; 0xfduy; 0xffuy;
0x01uy; 0x00uy; 0x06uy; 0x00uy; 0x03uy; 0x00uy; 0x01uy; 0x00uy; 0x01uy; 0x00uy; 0x01uy; 0x00uy;
0xfbuy; 0xffuy; 0xffuy; 0xffuy; 0x02uy; 0x00uy; 0xfeuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy;
0xfcuy; 0xffuy; 0xfbuy; 0xffuy; 0x04uy; 0x00uy; 0xfduy; 0xffuy; 0x00uy; 0x00uy; 0x05uy; 0x00uy;
0xfduy; 0xffuy; 0xffuy; 0xffuy; 0x00uy; 0x00uy; 0xfcuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy;
0x04uy; 0x00uy; 0xfeuy; 0xffuy; 0xffuy; 0xffuy; 0xfcuy; 0xffuy; 0x00uy; 0x00uy; 0xfeuy; 0xffuy;
0x01uy; 0x00uy; 0x01uy; 0x00uy; 0xfbuy; 0xffuy; 0xfcuy; 0xffuy; 0xfcuy; 0xffuy; 0x02uy; 0x00uy;
0x00uy; 0x00uy; 0xfeuy; 0xffuy; 0xffuy; 0xffuy; 0x01uy; 0x00uy; 0xfduy; 0xffuy; 0x01uy; 0x00uy;
0x02uy; 0x00uy; 0xfeuy; 0xffuy; 0xffuy; 0xffuy; 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy;
0xffuy; 0xffuy; 0x00uy; 0x00uy; 0x01uy; 0x00uy; 0x01uy; 0x00uy; 0x01uy; 0x00uy; 0x01uy; 0x00uy;
0xffuy; 0xffuy; 0x03uy; 0x00uy; 0xfeuy; 0xffuy; 0x02uy; 0x00uy; 0x03uy; 0x00uy; 0xfbuy; 0xffuy;
0x00uy; 0x00uy; 0xfduy; 0xffuy; 0xf9uy; 0xffuy; 0x04uy; 0x00uy; 0x02uy; 0x00uy; 0x02uy; 0x00uy;
0xfcuy; 0xffuy; 0x03uy; 0x00uy; 0xfduy; 0xffuy; 0x03uy; 0x00uy; 0x01uy; 0x00uy; 0x01uy; 0x00uy;
0xf7uy; 0xffuy; 0xfduy; 0xffuy; 0xffuy; 0xffuy; 0x02uy; 0x00uy; 0x04uy; 0x00uy; 0x04uy; 0x00uy;
0xfduy; 0xffuy; 0xffuy; 0xffuy; 0x00uy; 0x00uy; 0xfeuy; 0xffuy; 0x03uy; 0x00uy; 0x03uy; 0x00uy;
0x04uy; 0x00uy; 0x05uy; 0x00uy; 0xfduy; 0xffuy; 0xfauy; 0xffuy; 0x01uy; 0x00uy; 0xf8uy; 0xffuy;
0x01uy; 0x00uy; 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0xfduy; 0xffuy; 0xfbuy; 0xffuy; 0x00uy; 0x00uy;
0x02uy; 0x00uy; 0xfauy; 0xffuy; 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x02uy; 0x00uy; 0x03uy; 0x00uy;
0x04uy; 0x00uy; 0xfeuy; 0xffuy; 0x01uy; 0x00uy; 0x03uy; 0x00uy; 0xffuy; 0xffuy; 0x02uy; 0x00uy;
0xfbuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xfduy; 0xffuy; 0x02uy; 0x00uy; 0xfcuy; 0xffuy;
0x01uy; 0x00uy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x03uy; 0x00uy; 0x02uy; 0x00uy;
0x01uy; 0x00uy; 0x04uy; 0x00uy; 0xfeuy; 0xffuy; 0xfcuy; 0xffuy; 0xfcuy; 0xffuy; 0x01uy; 0x00uy;
0xffuy; 0xffuy; 0xffuy; 0xffuy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0x03uy; 0x00uy;
0xfeuy; 0xffuy; 0xffuy; 0xffuy; 0xfduy; 0xffuy; 0xfeuy; 0xffuy; 0xfduy; 0xffuy; 0x03uy; 0x00uy;
0xffuy; 0xffuy; 0xfeuy; 0xffuy; 0xfduy; 0xffuy; 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy;
0x02uy; 0x00uy; 0xfeuy; 0xffuy; 0x05uy; 0x00uy; 0xffuy; 0xffuy; 0x02uy; 0x00uy; 0xfduy; 0xffuy;
0xfduy; 0xffuy; 0xffuy; 0xffuy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0xfeuy; 0xffuy; 0xffuy; 0xffuy;
0x04uy; 0x00uy; 0x00uy; 0x00uy; 0x04uy; 0x00uy; 0x04uy; 0x00uy; 0xfeuy; 0xffuy; 0x02uy; 0x00uy;
0xf9uy; 0xffuy; 0x02uy; 0x00uy; 0x08uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0x00uy; 0x00uy;
0xb6uy; 0x27uy; 0xd5uy; 0x5euy; 0x52uy; 0xfduy; 0x89uy; 0x2euy; 0x92uy; 0x59uy; 0x69uy; 0xe7uy;
0x32uy; 0xb2uy; 0xacuy; 0x21uy
] | {
"checked_file": "/",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.KEM.KeyGen.fst.checked",
"Spec.Frodo.KEM.Encaps.fst.checked",
"Spec.Frodo.KEM.Decaps.fst.checked",
"Spec.Frodo.KEM.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.PrintSequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Test.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.PrintSequence",
"short_module": "PS"
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM.Decaps",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM.Encaps",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM.KeyGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"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.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"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": 1,
"max_fuel": 0,
"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": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit -> FStar.All.ML Prims.bool | FStar.All.ML | [
"ml"
] | [] | [
"Prims.unit",
"Prims.bool",
"FStar.IO.print_string",
"Spec.Frodo.Test.test_frodo",
"Spec.Frodo.Params.SHAKE128",
"Spec.Frodo.Test.test1_keypaircoins",
"Spec.Frodo.Test.test1_enccoins",
"Spec.Frodo.Test.test1_ss_expected",
"Spec.Frodo.Test.test1_pk_expected",
"Spec.Frodo.Test.test1_ct_expected",
"Spec.Frodo.Test.test1_sk_expected",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.max_size_t",
"Prims.op_GreaterThanOrEqual",
"FStar.List.Tot.Base.length",
"Lib.IntTypes.uint8",
"Spec.Frodo.Params.crypto_secretkeybytes",
"Spec.Frodo.Params.crypto_ciphertextbytes",
"Spec.Frodo.Params.crypto_publickeybytes",
"Spec.Frodo.Params.crypto_bytes",
"Spec.Frodo.Params.bytes_mu",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Spec.Frodo.Params.bytes_seed_a",
"Spec.Frodo.Params.frodo_alg",
"Spec.Frodo.Params.Frodo64"
] | [] | false | true | false | false | false | let test () : ML bool =
| [@@ inline_let ]let a = Frodo64 in
assert_norm (List.Tot.length test1_enccoins == 16);
assert_norm (List.Tot.length test1_keypaircoins == 2 * crypto_bytes a + bytes_seed_a);
assert_norm (List.Tot.length test1_enccoins == bytes_mu a);
assert_norm (List.Tot.length test1_ss_expected == crypto_bytes a);
assert_norm (List.Tot.length test1_pk_expected == crypto_publickeybytes a);
assert_norm (List.Tot.length test1_ct_expected == crypto_ciphertextbytes a);
assert_norm (List.Tot.length test1_sk_expected == crypto_secretkeybytes a);
IO.print_string "\nTest1. SHAKE128";
let res1 =
test_frodo a
SHAKE128
test1_keypaircoins
test1_enccoins
test1_ss_expected
test1_pk_expected
test1_ct_expected
test1_sk_expected
in
let result = res1 in
if result
then IO.print_string "\n\nFrodoKEM : Success!\n"
else IO.print_string "\n\nFrodoKEM: Failure :(\n";
result | false |
Vale.Curve25519.X64.FastUtil.fsti | Vale.Curve25519.X64.FastUtil.va_ens_Fast_add1 | val va_ens_Fast_add1
(va_b0: va_code)
(va_s0: va_state)
(dst_b inA_b: buffer64)
(inB: nat64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop | val va_ens_Fast_add1
(va_b0: va_code)
(va_s0: va_state)
(dst_b inA_b: buffer64)
(inB: nat64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop | let va_ens_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1 va_b0 va_s0 dst_b inA_b inB /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))) | {
"file_name": "obj/Vale.Curve25519.X64.FastUtil.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 90,
"end_line": 53,
"start_col": 0,
"start_line": 36
} | module Vale.Curve25519.X64.FastUtil
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Fast_add1
val va_code_Fast_add1 : va_dummy:unit -> Tot va_code
val va_codegen_success_Fast_add1 : va_dummy:unit -> Tot va_pbool
let va_req_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
: prop =
(va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastUtil.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB: Vale.X64.Memory.nat64 ->
va_sM: Vale.X64.Decls.va_state ->
va_fM: Vale.X64.Decls.va_fuel
-> Prims.prop | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Memory.buffer64",
"Vale.X64.Memory.nat64",
"Vale.X64.Decls.va_fuel",
"Prims.l_and",
"Vale.Curve25519.X64.FastUtil.va_req_Fast_add1",
"Vale.X64.Decls.va_ensure_total",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.eq2",
"Prims.int",
"Prims.op_Addition",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Decls.modifies_buffer",
"Vale.X64.Decls.va_get_mem",
"Prims.nat",
"Vale.Curve25519.Fast_defs.pow2_five",
"Vale.X64.Machine_s.rRax",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.buffer64_read",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_mem_layout",
"Vale.X64.Decls.va_update_mem_heaplet",
"Vale.X64.Decls.va_update_reg64",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_mem",
"Prims.prop"
] | [] | false | false | false | true | true | let va_ens_Fast_add1
(va_b0: va_code)
(va_s0: va_state)
(dst_b inA_b: buffer64)
(inB: nat64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop =
| (va_req_Fast_add1 va_b0 va_s0 dst_b inA_b inB /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\
(let a0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let a2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let a3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let a:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in
let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in
let d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in
let d3 = Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in
let d = Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in
d == a + va_get_reg64 rRdx va_s0 /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM
(va_update_flags va_sM
(va_update_mem_layout va_sM
(va_update_mem_heaplet 0
va_sM
(va_update_reg64 rR11
va_sM
(va_update_reg64 rR10
va_sM
(va_update_reg64 rR9
va_sM
(va_update_reg64 rR8
va_sM
(va_update_reg64 rRdx
va_sM
(va_update_reg64 rRax
va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))) | false |
PulseCore.Action.fst | PulseCore.Action.with_invariant | val with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p ** fp) (fun x -> p ** fp' x))
: act a (add_inv f_opens i) fp fp' | val with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p ** fp) (fun x -> p ** fp' x))
: act a (add_inv f_opens i) fp fp' | let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 34,
"end_line": 237,
"start_col": 0,
"start_line": 224
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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 |
i: PulseCore.Action.inv p {Prims.op_Negation (PulseCore.Action.mem_inv f_opens i)} ->
f: (_: Prims.unit -> PulseCore.Action.act a f_opens (p ** fp) (fun x -> p ** fp' x))
-> PulseCore.Action.act a (PulseCore.Action.add_inv f_opens i) fp fp' | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Action.inames",
"PulseCore.Action.inv",
"Prims.b2t",
"Prims.op_Negation",
"PulseCore.Action.mem_inv",
"Prims.unit",
"PulseCore.Action.act",
"PulseCore.Memory.star",
"PulseCore.Action.inames_disj",
"PulseCore.Action.add_inv",
"PulseCore.Action.mem_action_as_action",
"PulseCore.Memory.action_except",
"PulseCore.Memory.with_invariant",
"PulseCore.Memory.slprop",
"PulseCore.Action.action_as_mem_action",
"PulseCore.Memory.inames",
"PulseCore.Memory.add_inv",
"PulseCore.Action.action"
] | [] | false | false | false | false | false | let with_invariant
(#a: Type)
(#fp: slprop)
(#fp': (a -> slprop))
(#f_opens: inames)
(#p: slprop)
(i: inv p {not (mem_inv f_opens i)})
(f: (unit -> act a f_opens (p `star` fp) (fun x -> p `star` (fp' x))))
: act a (add_inv f_opens i) fp fp' =
| fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m | false |
StlcStrongDbParSubst.fst | StlcStrongDbParSubst.sub_inc | val sub_inc : var -> Tot exp | val sub_inc : var -> Tot exp | let sub_inc y = EVar (y+1) | {
"file_name": "examples/metatheory/StlcStrongDbParSubst.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 26,
"end_line": 63,
"start_col": 0,
"start_line": 63
} | (*
Copyright 2014-2015
Simon Forest - Inria and ENS Paris
Catalin Hritcu - Inria
Nikhil Swamy - 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 StlcStrongDbParSubst
open FStar.Constructive
open FStar.Classical
open FStar.FunctionalExtensionality
open FStar.StrongExcludedMiddle
(* Constructive-style progress and preservation proof for STLC with
strong reduction, using deBruijn indices and parallel substitution. *)
type typ =
| TArr : typ -> typ -> typ
| TUnit : typ
type var = nat
type exp =
| EVar : var -> exp
| EApp : exp -> exp -> exp
| ELam : typ -> exp -> exp
| EUnit : exp
(* Parallel substitution operation `subst` *)
(* The termination argument uses a lexicographic ordering composed of:
0) a bit saying whether the expression is a variable or not;
1) an _undecidable_ well-founded order on substitutions that
equates all renamings, equates all non-renamings, and makes
renamings strictly smaller than non-renamings; we write down a
non-constructive function is_renaming mapping substitutions
(infinite objects) to 0 (renaming) or 1 (non-renaming)
2) the structure of the expression e *)
type sub = var -> Tot exp
type renaming (s:sub) = (forall (x:var). EVar? (s x))
val is_renaming : s:sub -> GTot (n:int{ (renaming s ==> n=0) /\
(~(renaming s) ==> n=1)})
let is_renaming s = (if strong_excluded_middle (renaming s) then 0 else 1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Constructive.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "StlcStrongDbParSubst.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.StrongExcludedMiddle",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Constructive",
"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 | y: StlcStrongDbParSubst.var -> StlcStrongDbParSubst.exp | Prims.Tot | [
"total"
] | [] | [
"StlcStrongDbParSubst.var",
"StlcStrongDbParSubst.EVar",
"Prims.op_Addition",
"StlcStrongDbParSubst.exp"
] | [] | false | false | false | true | false | let sub_inc y =
| EVar (y + 1) | false |
StlcStrongDbParSubst.fst | StlcStrongDbParSubst.is_renaming | val is_renaming : s:sub -> GTot (n:int{ (renaming s ==> n=0) /\
(~(renaming s) ==> n=1)}) | val is_renaming : s:sub -> GTot (n:int{ (renaming s ==> n=0) /\
(~(renaming s) ==> n=1)}) | let is_renaming s = (if strong_excluded_middle (renaming s) then 0 else 1) | {
"file_name": "examples/metatheory/StlcStrongDbParSubst.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 74,
"end_line": 59,
"start_col": 0,
"start_line": 59
} | (*
Copyright 2014-2015
Simon Forest - Inria and ENS Paris
Catalin Hritcu - Inria
Nikhil Swamy - 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 StlcStrongDbParSubst
open FStar.Constructive
open FStar.Classical
open FStar.FunctionalExtensionality
open FStar.StrongExcludedMiddle
(* Constructive-style progress and preservation proof for STLC with
strong reduction, using deBruijn indices and parallel substitution. *)
type typ =
| TArr : typ -> typ -> typ
| TUnit : typ
type var = nat
type exp =
| EVar : var -> exp
| EApp : exp -> exp -> exp
| ELam : typ -> exp -> exp
| EUnit : exp
(* Parallel substitution operation `subst` *)
(* The termination argument uses a lexicographic ordering composed of:
0) a bit saying whether the expression is a variable or not;
1) an _undecidable_ well-founded order on substitutions that
equates all renamings, equates all non-renamings, and makes
renamings strictly smaller than non-renamings; we write down a
non-constructive function is_renaming mapping substitutions
(infinite objects) to 0 (renaming) or 1 (non-renaming)
2) the structure of the expression e *)
type sub = var -> Tot exp
type renaming (s:sub) = (forall (x:var). EVar? (s x))
val is_renaming : s:sub -> GTot (n:int{ (renaming s ==> n=0) /\ | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Constructive.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "StlcStrongDbParSubst.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.StrongExcludedMiddle",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Constructive",
"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: StlcStrongDbParSubst.sub
-> Prims.GTot
(n:
Prims.int
{ (StlcStrongDbParSubst.renaming s ==> n = 0) /\
(~(StlcStrongDbParSubst.renaming s) ==> n = 1) }) | Prims.GTot | [
"sometrivial"
] | [] | [
"StlcStrongDbParSubst.sub",
"FStar.StrongExcludedMiddle.strong_excluded_middle",
"StlcStrongDbParSubst.renaming",
"Prims.bool",
"Prims.int",
"Prims.l_and",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_Equality",
"Prims.l_not"
] | [] | false | false | false | false | false | let is_renaming s =
| (if strong_excluded_middle (renaming s) then 0 else 1) | false |
PulseCore.Action.fst | PulseCore.Action.pure_true | val pure_true ()
: slprop_equiv (pure True) emp | val pure_true ()
: slprop_equiv (pure True) emp | let pure_true ()
= Mem.pure_true_emp ();
slprop_equiv_elim (pure True) emp;
coerce_eq () <| slprop_equiv_refl (pure True) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 47,
"end_line": 338,
"start_col": 0,
"start_line": 335
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p)
let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m
///////////////////////////////////////////////////////////////////
// Core operations on references
///////////////////////////////////////////////////////////////////
let ref (a:Type u#a) (p:pcm a) = ref a p
let ref_null (#a:Type u#a) (p:pcm a) = core_ref_null
let is_ref_null (#a:Type u#a) (#p:pcm a) (r:ref a p) = core_ref_is_null r
let pts_to = pts_to
let pts_to_not_null #a #p r v =
fun #ictx -> mem_action_as_action _ _ _ _ (pts_to_not_null_action ictx r v)
let alloc
(#a:Type u#1)
(#pcm:pcm a)
(x:a{compatible pcm x x /\ pcm.refine x})
: act (ref a pcm) emp_inames emp (fun r -> pts_to r x)
= fun #ictx ->
mem_action_as_action _ _ _ _
(alloc_action ictx x)
let read
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x:erased a)
(f:(v:a{compatible p x v}
-> GTot (y:a{compatible p y v /\
FStar.PCM.frame_compatible p x v y})))
: act (v:a{compatible p x v /\ p.refine v}) emp_inames
(pts_to r x)
(fun v -> pts_to r (f v))
= fun #ictx ->
mem_action_as_action _ _ _ _ (select_refine ictx r x f)
let write
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x y:Ghost.erased a)
(f:FStar.PCM.frame_preserving_upd p x y)
: act unit emp_inames
(pts_to r x)
(fun _ -> pts_to r y)
= fun #ictx -> mem_action_as_action _ _ _ _ (upd_gen ictx r x y f)
let share
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a{composable pcm v0 v1})
: act unit emp_inames
(pts_to r (v0 `op pcm` v1))
(fun _ -> pts_to r v0 `star` pts_to r v1)
= fun #ictx -> mem_action_as_action _ _ _ _ (split_action ictx r v0 v1)
let gather
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a)
: act (squash (composable pcm v0 v1))
emp_inames
(pts_to r v0 `star` pts_to r v1)
(fun _ -> pts_to r (op pcm v0 v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (gather_action ictx r v0 v1)
let witnessed = witnessed
let witness
(#a:Type)
(#pcm:pcm a)
(r:erased (ref a pcm))
(fact:stable_property pcm)
(v:Ghost.erased a)
(pf:squash (forall z. compatible pcm v z ==> fact z))
: act (witnessed r fact) emp_inames (pts_to r v) (fun _ -> pts_to r v)
= fun #ictx -> mem_action_as_action _ _ _ _ (witness ictx r fact v pf)
let recall
(#a:Type u#1)
(#pcm:pcm a)
(#fact:property a)
(r:erased (ref a pcm))
(v:Ghost.erased a)
(w:witnessed r fact)
: act (v1:Ghost.erased a{compatible pcm v v1})
emp_inames
(pts_to r v)
(fun v1 -> pts_to r v `star` pure (fact v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (recall ictx r v w)
///////////////////////////////////////////////////////////////////
// pure | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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
-> PulseCore.InstantiatedSemantics.slprop_equiv (PulseCore.InstantiatedSemantics.pure Prims.l_True
)
PulseCore.InstantiatedSemantics.emp | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"FStar.Pervasives.coerce_eq",
"PulseCore.InstantiatedSemantics.slprop_equiv",
"PulseCore.InstantiatedSemantics.pure",
"Prims.l_True",
"PulseCore.InstantiatedSemantics.emp",
"PulseCore.InstantiatedSemantics.slprop_equiv_refl",
"PulseCore.InstantiatedSemantics.slprop_equiv_elim",
"PulseCore.Memory.pure_true_emp"
] | [] | false | false | false | true | false | let pure_true () =
| Mem.pure_true_emp ();
slprop_equiv_elim (pure True) emp;
coerce_eq () <| slprop_equiv_refl (pure True) | false |
PulseCore.Action.fst | PulseCore.Action.share | val share
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a{composable pcm v0 v1})
: act unit emp_inames
(pts_to r (v0 `op pcm` v1))
(fun _ -> pts_to r v0 ** pts_to r v1) | val share
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a{composable pcm v0 v1})
: act unit emp_inames
(pts_to r (v0 `op pcm` v1))
(fun _ -> pts_to r v0 ** pts_to r v1) | let share
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a{composable pcm v0 v1})
: act unit emp_inames
(pts_to r (v0 `op pcm` v1))
(fun _ -> pts_to r v0 `star` pts_to r v1)
= fun #ictx -> mem_action_as_action _ _ _ _ (split_action ictx r v0 v1) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 71,
"end_line": 294,
"start_col": 0,
"start_line": 285
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p)
let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m
///////////////////////////////////////////////////////////////////
// Core operations on references
///////////////////////////////////////////////////////////////////
let ref (a:Type u#a) (p:pcm a) = ref a p
let ref_null (#a:Type u#a) (p:pcm a) = core_ref_null
let is_ref_null (#a:Type u#a) (#p:pcm a) (r:ref a p) = core_ref_is_null r
let pts_to = pts_to
let pts_to_not_null #a #p r v =
fun #ictx -> mem_action_as_action _ _ _ _ (pts_to_not_null_action ictx r v)
let alloc
(#a:Type u#1)
(#pcm:pcm a)
(x:a{compatible pcm x x /\ pcm.refine x})
: act (ref a pcm) emp_inames emp (fun r -> pts_to r x)
= fun #ictx ->
mem_action_as_action _ _ _ _
(alloc_action ictx x)
let read
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x:erased a)
(f:(v:a{compatible p x v}
-> GTot (y:a{compatible p y v /\
FStar.PCM.frame_compatible p x v y})))
: act (v:a{compatible p x v /\ p.refine v}) emp_inames
(pts_to r x)
(fun v -> pts_to r (f v))
= fun #ictx ->
mem_action_as_action _ _ _ _ (select_refine ictx r x f)
let write
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x y:Ghost.erased a)
(f:FStar.PCM.frame_preserving_upd p x y)
: act unit emp_inames
(pts_to r x)
(fun _ -> pts_to r y)
= fun #ictx -> mem_action_as_action _ _ _ _ (upd_gen ictx r x y f) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: PulseCore.Action.ref a pcm ->
v0: FStar.Ghost.erased a ->
v1:
FStar.Ghost.erased a
{FStar.PCM.composable pcm (FStar.Ghost.reveal v0) (FStar.Ghost.reveal v1)}
-> PulseCore.Action.act Prims.unit
PulseCore.Action.emp_inames
(PulseCore.Action.pts_to r (FStar.PCM.op pcm (FStar.Ghost.reveal v0) (FStar.Ghost.reveal v1)))
(fun _ ->
PulseCore.Action.pts_to r (FStar.Ghost.reveal v0) **
PulseCore.Action.pts_to r (FStar.Ghost.reveal v1)) | Prims.Tot | [
"total"
] | [] | [
"FStar.PCM.pcm",
"PulseCore.Action.ref",
"FStar.Ghost.erased",
"FStar.PCM.composable",
"FStar.Ghost.reveal",
"PulseCore.Action.inames_disj",
"PulseCore.Action.emp_inames",
"PulseCore.Action.mem_action_as_action",
"Prims.unit",
"PulseCore.Memory.pts_to",
"FStar.PCM.op",
"PulseCore.Memory.star",
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Memory.split_action",
"PulseCore.Action.action",
"PulseCore.Action.pts_to",
"PulseCore.Action.act",
"PulseCore.InstantiatedSemantics.op_Star_Star"
] | [] | false | false | false | false | false | let share
(#a: Type)
(#pcm: pcm a)
(r: ref a pcm)
(v0: FStar.Ghost.erased a)
(v1: FStar.Ghost.erased a {composable pcm v0 v1})
: act unit emp_inames (pts_to r (op pcm v0 v1)) (fun _ -> (pts_to r v0) `star` (pts_to r v1)) =
| fun #ictx -> mem_action_as_action _ _ _ _ (split_action ictx r v0 v1) | false |
PulseCore.Action.fst | PulseCore.Action.lift0 | val lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: I.stt a pre post | val lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: I.stt a pre post | let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 32,
"end_line": 201,
"start_col": 0,
"start_line": 198
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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 | m: PulseCore.Action.act a opens pre post -> PulseCore.InstantiatedSemantics.stt a pre post | Prims.Tot | [
"total"
] | [] | [
"PulseCore.Action.inames",
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Action.act",
"PulseCore.Action.stt_of_action0",
"PulseCore.Action.emp_inames",
"PulseCore.InstantiatedSemantics.stt"
] | [] | false | false | false | false | false | let lift0 (#a: Type u#0) #opens #pre #post (m: act a opens pre post) : stt a pre post =
| stt_of_action0 (m #emp_inames) | false |
Vale.Curve25519.X64.FastUtil.fsti | Vale.Curve25519.X64.FastUtil.va_wp_Fast_add1 | val va_wp_Fast_add1
(dst_b inA_b: buffer64)
(inB: nat64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Fast_add1
(dst_b inA_b: buffer64)
(inB: nat64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
adx_enabled /\ bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0)
(va_get_mem va_s0) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rdx:nat64) (va_x_r8:nat64)
(va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64) (va_x_heap0:vale_heap)
(va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11
va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8
(va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.Curve25519.X64.FastUtil.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 33,
"end_line": 116,
"start_col": 0,
"start_line": 87
} | module Vale.Curve25519.X64.FastUtil
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Fast_add1
val va_code_Fast_add1 : va_dummy:unit -> Tot va_code
val va_codegen_success_Fast_add1 : va_dummy:unit -> Tot va_pbool
let va_req_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
: prop =
(va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0))
let va_ens_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1 va_b0 va_s0 dst_b inA_b inB /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fast_add1 : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastUtil.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB: Vale.X64.Memory.nat64 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Memory.buffer64",
"Vale.X64.Memory.nat64",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.adx_enabled",
"Vale.X64.CPU_Features_s.bmi2_enabled",
"Vale.X64.Memory.is_initial_heap",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Decls.va_get_mem",
"Prims.l_or",
"Vale.X64.Decls.buffers_disjoint",
"Prims.eq2",
"Vale.X64.Decls.validDstAddrs64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRdi",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validSrcAddrs64",
"Vale.X64.Machine_s.rRsi",
"Vale.Def.Words_s.nat64",
"Vale.X64.Machine_s.rRdx",
"Prims.nat",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.X64.Decls.buffer64_read",
"Prims.l_Forall",
"Vale.X64.InsBasic.vale_heap",
"Vale.Arch.HeapImpl.vale_heap_layout",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Prims.int",
"Prims.op_Addition",
"Vale.X64.Decls.modifies_buffer",
"Vale.Curve25519.Fast_defs.pow2_five",
"Vale.X64.Machine_s.rRax",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_mem_layout",
"Vale.X64.Decls.va_upd_mem_heaplet",
"Vale.X64.Decls.va_upd_reg64",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Decls.va_upd_mem"
] | [] | false | false | false | true | true | let va_wp_Fast_add1
(dst_b inA_b: buffer64)
(inB: nat64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_get_ok va_s0 /\
(let a0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let a2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let a3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let a:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdi va_s0)
dst_b
4
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0)
inA_b
4
(va_get_mem_layout va_s0)
Secret /\ inB == va_get_reg64 rRdx va_s0) /\
(forall (va_x_mem: vale_heap) (va_x_rax: nat64) (va_x_rdx: nat64) (va_x_r8: nat64)
(va_x_r9: nat64) (va_x_r10: nat64) (va_x_r11: nat64) (va_x_heap0: vale_heap)
(va_x_memLayout: vale_heap_layout) (va_x_efl: Vale.X64.Flags.t).
let va_sM =
va_upd_flags va_x_efl
(va_upd_mem_layout va_x_memLayout
(va_upd_mem_heaplet 0
va_x_heap0
(va_upd_reg64 rR11
va_x_r11
(va_upd_reg64 rR10
va_x_r10
(va_upd_reg64 rR9
va_x_r9
(va_upd_reg64 rR8
va_x_r8
(va_upd_reg64 rRdx
va_x_rdx
(va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))))))
)
in
va_get_ok va_sM /\
(let a0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let a2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let a3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let a:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in
let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in
let d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in
let d3 = Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in
let d = Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in
d == a + va_get_reg64 rRdx va_s0 /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==>
va_k va_sM (()))) | false |
PulseCore.Action.fst | PulseCore.Action.intro_exists'' | val intro_exists'' (#a: Type u#a) (p: (a -> slprop)) (x: erased a)
: act unit emp_inames (p x) (thunk (exists* x. p x)) | val intro_exists'' (#a: Type u#a) (p: (a -> slprop)) (x: erased a)
: act unit emp_inames (p x) (thunk (exists* x. p x)) | let intro_exists'' (#a:Type u#a) (p:a -> slprop) (x:erased a)
: act unit emp_inames (p x) (thunk (exists* x. p x))
= coerce_eq (exists_equiv #a #p) (intro_exists' #a p x) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 55,
"end_line": 366,
"start_col": 0,
"start_line": 364
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p)
let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m
///////////////////////////////////////////////////////////////////
// Core operations on references
///////////////////////////////////////////////////////////////////
let ref (a:Type u#a) (p:pcm a) = ref a p
let ref_null (#a:Type u#a) (p:pcm a) = core_ref_null
let is_ref_null (#a:Type u#a) (#p:pcm a) (r:ref a p) = core_ref_is_null r
let pts_to = pts_to
let pts_to_not_null #a #p r v =
fun #ictx -> mem_action_as_action _ _ _ _ (pts_to_not_null_action ictx r v)
let alloc
(#a:Type u#1)
(#pcm:pcm a)
(x:a{compatible pcm x x /\ pcm.refine x})
: act (ref a pcm) emp_inames emp (fun r -> pts_to r x)
= fun #ictx ->
mem_action_as_action _ _ _ _
(alloc_action ictx x)
let read
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x:erased a)
(f:(v:a{compatible p x v}
-> GTot (y:a{compatible p y v /\
FStar.PCM.frame_compatible p x v y})))
: act (v:a{compatible p x v /\ p.refine v}) emp_inames
(pts_to r x)
(fun v -> pts_to r (f v))
= fun #ictx ->
mem_action_as_action _ _ _ _ (select_refine ictx r x f)
let write
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x y:Ghost.erased a)
(f:FStar.PCM.frame_preserving_upd p x y)
: act unit emp_inames
(pts_to r x)
(fun _ -> pts_to r y)
= fun #ictx -> mem_action_as_action _ _ _ _ (upd_gen ictx r x y f)
let share
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a{composable pcm v0 v1})
: act unit emp_inames
(pts_to r (v0 `op pcm` v1))
(fun _ -> pts_to r v0 `star` pts_to r v1)
= fun #ictx -> mem_action_as_action _ _ _ _ (split_action ictx r v0 v1)
let gather
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a)
: act (squash (composable pcm v0 v1))
emp_inames
(pts_to r v0 `star` pts_to r v1)
(fun _ -> pts_to r (op pcm v0 v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (gather_action ictx r v0 v1)
let witnessed = witnessed
let witness
(#a:Type)
(#pcm:pcm a)
(r:erased (ref a pcm))
(fact:stable_property pcm)
(v:Ghost.erased a)
(pf:squash (forall z. compatible pcm v z ==> fact z))
: act (witnessed r fact) emp_inames (pts_to r v) (fun _ -> pts_to r v)
= fun #ictx -> mem_action_as_action _ _ _ _ (witness ictx r fact v pf)
let recall
(#a:Type u#1)
(#pcm:pcm a)
(#fact:property a)
(r:erased (ref a pcm))
(v:Ghost.erased a)
(w:witnessed r fact)
: act (v1:Ghost.erased a{compatible pcm v v1})
emp_inames
(pts_to r v)
(fun v1 -> pts_to r v `star` pure (fact v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (recall ictx r v w)
///////////////////////////////////////////////////////////////////
// pure
///////////////////////////////////////////////////////////////////
let pure_true ()
= Mem.pure_true_emp ();
slprop_equiv_elim (pure True) emp;
coerce_eq () <| slprop_equiv_refl (pure True)
let intro_pure (p:prop) (pf:squash p)
: act unit emp_inames emp (fun _ -> pure p)
= fun #ictx -> mem_action_as_action _ _ _ _ (intro_pure #ictx p pf)
let elim_pure (p:prop)
: act (squash p) emp_inames (pure p) (fun _ -> emp)
= fun #ictx -> mem_action_as_action _ _ _ _ (elim_pure #ictx p)
///////////////////////////////////////////////////////////////////
// exists*
///////////////////////////////////////////////////////////////////
module F = FStar.FunctionalExtensionality
let exists_equiv (#a:_) (#p:a -> slprop)
: squash (op_exists_Star p == (exists* x. p x))
= let pf = I.slprop_equiv_exists p (fun x -> p x) () in
let pf = FStar.Squash.return_squash pf in
I.slprop_equiv_elim (op_exists_Star p) (exists* x. p x)
let thunk (p:slprop) = fun (_:unit) -> p
let intro_exists' (#a:Type u#a) (p:a -> slprop) (x:erased a)
: act unit emp_inames (p x) (thunk (op_exists_Star p))
= fun #ictx -> mem_action_as_action _ _ _ _ (intro_exists #ictx (F.on_dom a p) x) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: (_: a -> PulseCore.InstantiatedSemantics.slprop) -> x: FStar.Ghost.erased a
-> PulseCore.Action.act Prims.unit
PulseCore.Action.emp_inames
(p (FStar.Ghost.reveal x))
(PulseCore.Action.thunk (exists* (x: a). p x)) | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"FStar.Ghost.erased",
"FStar.Pervasives.coerce_eq",
"PulseCore.Action.act",
"Prims.unit",
"PulseCore.Action.emp_inames",
"FStar.Ghost.reveal",
"PulseCore.Action.thunk",
"PulseCore.InstantiatedSemantics.op_exists_Star",
"PulseCore.Action.exists_equiv",
"PulseCore.Action.intro_exists'"
] | [] | false | false | false | false | false | let intro_exists'' (#a: Type u#a) (p: (a -> slprop)) (x: erased a)
: act unit emp_inames (p x) (thunk (exists* x. p x)) =
| coerce_eq (exists_equiv #a #p) (intro_exists' #a p x) | false |
PulseCore.Action.fst | PulseCore.Action.exists_equiv | val exists_equiv (#a: _) (#p: (a -> slprop)) : squash (op_exists_Star p == (exists* x. p x)) | val exists_equiv (#a: _) (#p: (a -> slprop)) : squash (op_exists_Star p == (exists* x. p x)) | let exists_equiv (#a:_) (#p:a -> slprop)
: squash (op_exists_Star p == (exists* x. p x))
= let pf = I.slprop_equiv_exists p (fun x -> p x) () in
let pf = FStar.Squash.return_squash pf in
I.slprop_equiv_elim (op_exists_Star p) (exists* x. p x) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 59,
"end_line": 356,
"start_col": 0,
"start_line": 352
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p)
let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m
///////////////////////////////////////////////////////////////////
// Core operations on references
///////////////////////////////////////////////////////////////////
let ref (a:Type u#a) (p:pcm a) = ref a p
let ref_null (#a:Type u#a) (p:pcm a) = core_ref_null
let is_ref_null (#a:Type u#a) (#p:pcm a) (r:ref a p) = core_ref_is_null r
let pts_to = pts_to
let pts_to_not_null #a #p r v =
fun #ictx -> mem_action_as_action _ _ _ _ (pts_to_not_null_action ictx r v)
let alloc
(#a:Type u#1)
(#pcm:pcm a)
(x:a{compatible pcm x x /\ pcm.refine x})
: act (ref a pcm) emp_inames emp (fun r -> pts_to r x)
= fun #ictx ->
mem_action_as_action _ _ _ _
(alloc_action ictx x)
let read
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x:erased a)
(f:(v:a{compatible p x v}
-> GTot (y:a{compatible p y v /\
FStar.PCM.frame_compatible p x v y})))
: act (v:a{compatible p x v /\ p.refine v}) emp_inames
(pts_to r x)
(fun v -> pts_to r (f v))
= fun #ictx ->
mem_action_as_action _ _ _ _ (select_refine ictx r x f)
let write
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x y:Ghost.erased a)
(f:FStar.PCM.frame_preserving_upd p x y)
: act unit emp_inames
(pts_to r x)
(fun _ -> pts_to r y)
= fun #ictx -> mem_action_as_action _ _ _ _ (upd_gen ictx r x y f)
let share
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a{composable pcm v0 v1})
: act unit emp_inames
(pts_to r (v0 `op pcm` v1))
(fun _ -> pts_to r v0 `star` pts_to r v1)
= fun #ictx -> mem_action_as_action _ _ _ _ (split_action ictx r v0 v1)
let gather
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a)
: act (squash (composable pcm v0 v1))
emp_inames
(pts_to r v0 `star` pts_to r v1)
(fun _ -> pts_to r (op pcm v0 v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (gather_action ictx r v0 v1)
let witnessed = witnessed
let witness
(#a:Type)
(#pcm:pcm a)
(r:erased (ref a pcm))
(fact:stable_property pcm)
(v:Ghost.erased a)
(pf:squash (forall z. compatible pcm v z ==> fact z))
: act (witnessed r fact) emp_inames (pts_to r v) (fun _ -> pts_to r v)
= fun #ictx -> mem_action_as_action _ _ _ _ (witness ictx r fact v pf)
let recall
(#a:Type u#1)
(#pcm:pcm a)
(#fact:property a)
(r:erased (ref a pcm))
(v:Ghost.erased a)
(w:witnessed r fact)
: act (v1:Ghost.erased a{compatible pcm v v1})
emp_inames
(pts_to r v)
(fun v1 -> pts_to r v `star` pure (fact v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (recall ictx r v w)
///////////////////////////////////////////////////////////////////
// pure
///////////////////////////////////////////////////////////////////
let pure_true ()
= Mem.pure_true_emp ();
slprop_equiv_elim (pure True) emp;
coerce_eq () <| slprop_equiv_refl (pure True)
let intro_pure (p:prop) (pf:squash p)
: act unit emp_inames emp (fun _ -> pure p)
= fun #ictx -> mem_action_as_action _ _ _ _ (intro_pure #ictx p pf)
let elim_pure (p:prop)
: act (squash p) emp_inames (pure p) (fun _ -> emp)
= fun #ictx -> mem_action_as_action _ _ _ _ (elim_pure #ictx p)
///////////////////////////////////////////////////////////////////
// exists*
/////////////////////////////////////////////////////////////////// | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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.squash ((exists . p) == (exists* (x: a). p x)) | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.InstantiatedSemantics.slprop_equiv_elim",
"PulseCore.InstantiatedSemantics.op_exists_Star",
"Prims.squash",
"PulseCore.InstantiatedSemantics.slprop_equiv",
"FStar.Squash.return_squash",
"PulseCore.InstantiatedSemantics.slprop_equiv_exists",
"Prims.eq2"
] | [] | false | false | true | false | false | let exists_equiv (#a: _) (#p: (a -> slprop)) : squash (op_exists_Star p == (exists* x. p x)) =
| let pf = I.slprop_equiv_exists p (fun x -> p x) () in
let pf = FStar.Squash.return_squash pf in
I.slprop_equiv_elim (op_exists_Star p) (exists* x. p x) | false |
Vale.Curve25519.X64.FastUtil.fsti | Vale.Curve25519.X64.FastUtil.va_req_Cswap2 | val va_req_Cswap2 (va_b0: va_code) (va_s0: va_state) (bit_in: nat64) (p0_b p1_b: buffer64) : prop | val va_req_Cswap2 (va_b0: va_code) (va_s0: va_state) (bit_in: nat64) (p0_b p1_b: buffer64) : prop | let va_req_Cswap2 (va_b0:va_code) (va_s0:va_state) (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64) :
prop =
(va_require_total va_b0 (va_code_Cswap2 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in
let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0)
in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem
va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3
(va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in let
(old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in
let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0)
in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem
va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3
(va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ bit_in == va_get_reg64 rRdi va_s0 /\
va_get_reg64 rRdi va_s0 <= 1 /\ (Vale.X64.Decls.buffers_disjoint p1_b p0_b \/ p1_b == p0_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRsi va_s0) p0_b 8
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdx va_s0) p1_b 8 (va_get_mem_layout va_s0) Secret)) | {
"file_name": "obj/Vale.Curve25519.X64.FastUtil.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 71,
"end_line": 332,
"start_col": 0,
"start_line": 307
} | module Vale.Curve25519.X64.FastUtil
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Fast_add1
val va_code_Fast_add1 : va_dummy:unit -> Tot va_code
val va_codegen_success_Fast_add1 : va_dummy:unit -> Tot va_pbool
let va_req_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
: prop =
(va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0))
let va_ens_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1 va_b0 va_s0 dst_b inA_b inB /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fast_add1 : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
adx_enabled /\ bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0)
(va_get_mem va_s0) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rdx:nat64) (va_x_r8:nat64)
(va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64) (va_x_heap0:vale_heap)
(va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11
va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8
(va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) ==> va_k va_sM (())))
val va_wpProof_Fast_add1 : dst_b:buffer64 -> inA_b:buffer64 -> inB:nat64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_add1 dst_b inA_b inB va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_add1 ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) : (va_quickCode unit
(va_code_Fast_add1 ())) =
(va_QProc (va_code_Fast_add1 ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx;
va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fast_add1 dst_b inA_b inB) (va_wpProof_Fast_add1 dst_b
inA_b inB))
//--
//-- Fast_add1_stdcall
val va_code_Fast_add1_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fast_add1_stdcall : win:bool -> Tot va_pbool
let va_req_Fast_add1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) : prop =
(va_require_total va_b0 (va_code_Fast_add1_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret))
let va_ens_Fast_add1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1_stdcall va_b0 va_s0 win dst_b inA_b inB_in /\ va_ensure_total va_b0 va_s0 va_sM
va_fM /\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fast_add1_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_in:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_add1_stdcall win) va_s0 /\ va_get_ok va_s0 /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let a0 = Vale.X64.Decls.buffer64_read
inA_b 0 (va_get_mem va_s0) in let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0)
in let a2 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fast_add1_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_in:nat64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in =
va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rbx:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64) (va_x_rbp:nat64)
(va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64)
(va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let a0 =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) ==> va_k va_sM (())))
val va_wpProof_Fast_add1_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_in:nat64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_add1_stdcall win dst_b inA_b inB_in va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_add1_stdcall win)
([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags;
va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10;
va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi;
va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax;
va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_add1_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_in:nat64) :
(va_quickCode unit (va_code_Fast_add1_stdcall win)) =
(va_QProc (va_code_Fast_add1_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fast_add1_stdcall win dst_b inA_b
inB_in) (va_wpProof_Fast_add1_stdcall win dst_b inA_b inB_in))
//--
//-- Cswap2
val va_code_Cswap2 : va_dummy:unit -> Tot va_code | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastUtil.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
bit_in: Vale.X64.Memory.nat64 ->
p0_b: Vale.X64.Memory.buffer64 ->
p1_b: Vale.X64.Memory.buffer64
-> Prims.prop | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Memory.nat64",
"Vale.X64.Memory.buffer64",
"Prims.l_and",
"Vale.X64.Decls.va_require_total",
"Vale.Curve25519.X64.FastUtil.va_code_Cswap2",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.Memory.is_initial_heap",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Decls.va_get_mem",
"Prims.eq2",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRdi",
"Prims.op_LessThanOrEqual",
"Prims.l_or",
"Vale.X64.Decls.buffers_disjoint",
"Vale.X64.Decls.validDstAddrs64",
"Vale.X64.Machine_s.rRsi",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Decls.buffer64_read",
"Prims.prop"
] | [] | false | false | false | true | true | let va_req_Cswap2 (va_b0: va_code) (va_s0: va_state) (bit_in: nat64) (p0_b p1_b: buffer64) : prop =
| (va_require_total va_b0 (va_code_Cswap2 ()) va_s0 /\ va_get_ok va_s0 /\
(let old_p0_0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in
let old_p0_1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0) in
let old_p0_2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_s0) in
let old_p0_3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0) in
let old_p0_4:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_s0) in
let old_p0_5:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in
let old_p0_6:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in
let old_p0_7:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in
let old_p1_0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in
let old_p1_1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0) in
let old_p1_2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_s0) in
let old_p1_3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0) in
let old_p1_4:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_s0) in
let old_p1_5:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in
let old_p1_6:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in
let old_p1_7:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
bit_in == va_get_reg64 rRdi va_s0 /\ va_get_reg64 rRdi va_s0 <= 1 /\
(Vale.X64.Decls.buffers_disjoint p1_b p0_b \/ p1_b == p0_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0)
p0_b
8
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdx va_s0)
p1_b
8
(va_get_mem_layout va_s0)
Secret)) | false |
PulseCore.Action.fst | PulseCore.Action.gather | val gather
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a)
: act (squash (composable pcm v0 v1))
emp_inames
(pts_to r v0 ** pts_to r v1)
(fun _ -> pts_to r (op pcm v0 v1)) | val gather
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a)
: act (squash (composable pcm v0 v1))
emp_inames
(pts_to r v0 ** pts_to r v1)
(fun _ -> pts_to r (op pcm v0 v1)) | let gather
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a)
: act (squash (composable pcm v0 v1))
emp_inames
(pts_to r v0 `star` pts_to r v1)
(fun _ -> pts_to r (op pcm v0 v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (gather_action ictx r v0 v1) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 72,
"end_line": 306,
"start_col": 0,
"start_line": 296
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p)
let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m
///////////////////////////////////////////////////////////////////
// Core operations on references
///////////////////////////////////////////////////////////////////
let ref (a:Type u#a) (p:pcm a) = ref a p
let ref_null (#a:Type u#a) (p:pcm a) = core_ref_null
let is_ref_null (#a:Type u#a) (#p:pcm a) (r:ref a p) = core_ref_is_null r
let pts_to = pts_to
let pts_to_not_null #a #p r v =
fun #ictx -> mem_action_as_action _ _ _ _ (pts_to_not_null_action ictx r v)
let alloc
(#a:Type u#1)
(#pcm:pcm a)
(x:a{compatible pcm x x /\ pcm.refine x})
: act (ref a pcm) emp_inames emp (fun r -> pts_to r x)
= fun #ictx ->
mem_action_as_action _ _ _ _
(alloc_action ictx x)
let read
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x:erased a)
(f:(v:a{compatible p x v}
-> GTot (y:a{compatible p y v /\
FStar.PCM.frame_compatible p x v y})))
: act (v:a{compatible p x v /\ p.refine v}) emp_inames
(pts_to r x)
(fun v -> pts_to r (f v))
= fun #ictx ->
mem_action_as_action _ _ _ _ (select_refine ictx r x f)
let write
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x y:Ghost.erased a)
(f:FStar.PCM.frame_preserving_upd p x y)
: act unit emp_inames
(pts_to r x)
(fun _ -> pts_to r y)
= fun #ictx -> mem_action_as_action _ _ _ _ (upd_gen ictx r x y f)
let share
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a{composable pcm v0 v1})
: act unit emp_inames
(pts_to r (v0 `op pcm` v1))
(fun _ -> pts_to r v0 `star` pts_to r v1)
= fun #ictx -> mem_action_as_action _ _ _ _ (split_action ictx r v0 v1) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: PulseCore.Action.ref a pcm -> v0: FStar.Ghost.erased a -> v1: FStar.Ghost.erased a
-> PulseCore.Action.act (Prims.squash (FStar.PCM.composable pcm
(FStar.Ghost.reveal v0)
(FStar.Ghost.reveal v1)))
PulseCore.Action.emp_inames
(PulseCore.Action.pts_to r (FStar.Ghost.reveal v0) **
PulseCore.Action.pts_to r (FStar.Ghost.reveal v1))
(fun _ ->
PulseCore.Action.pts_to r
(FStar.PCM.op pcm (FStar.Ghost.reveal v0) (FStar.Ghost.reveal v1))) | Prims.Tot | [
"total"
] | [] | [
"FStar.PCM.pcm",
"PulseCore.Action.ref",
"FStar.Ghost.erased",
"PulseCore.Action.inames_disj",
"PulseCore.Action.emp_inames",
"PulseCore.Action.mem_action_as_action",
"Prims.unit",
"FStar.PCM.composable",
"FStar.Ghost.reveal",
"PulseCore.Memory.star",
"PulseCore.Memory.pts_to",
"FStar.PCM.op",
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Memory.gather_action",
"PulseCore.Action.action",
"Prims.squash",
"PulseCore.Action.pts_to",
"PulseCore.Action.act",
"PulseCore.InstantiatedSemantics.op_Star_Star"
] | [] | false | false | false | false | false | let gather (#a: Type) (#pcm: pcm a) (r: ref a pcm) (v0 v1: FStar.Ghost.erased a)
: act (squash (composable pcm v0 v1))
emp_inames
((pts_to r v0) `star` (pts_to r v1))
(fun _ -> pts_to r (op pcm v0 v1)) =
| fun #ictx -> mem_action_as_action _ _ _ _ (gather_action ictx r v0 v1) | false |
StlcStrongDbParSubst.fst | StlcStrongDbParSubst.extend | val extend : typ -> env -> Tot env | val extend : typ -> env -> Tot env | let extend t g y = if y = 0 then Some t
else g (y-1) | {
"file_name": "examples/metatheory/StlcStrongDbParSubst.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 31,
"end_line": 118,
"start_col": 0,
"start_line": 117
} | (*
Copyright 2014-2015
Simon Forest - Inria and ENS Paris
Catalin Hritcu - Inria
Nikhil Swamy - 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 StlcStrongDbParSubst
open FStar.Constructive
open FStar.Classical
open FStar.FunctionalExtensionality
open FStar.StrongExcludedMiddle
(* Constructive-style progress and preservation proof for STLC with
strong reduction, using deBruijn indices and parallel substitution. *)
type typ =
| TArr : typ -> typ -> typ
| TUnit : typ
type var = nat
type exp =
| EVar : var -> exp
| EApp : exp -> exp -> exp
| ELam : typ -> exp -> exp
| EUnit : exp
(* Parallel substitution operation `subst` *)
(* The termination argument uses a lexicographic ordering composed of:
0) a bit saying whether the expression is a variable or not;
1) an _undecidable_ well-founded order on substitutions that
equates all renamings, equates all non-renamings, and makes
renamings strictly smaller than non-renamings; we write down a
non-constructive function is_renaming mapping substitutions
(infinite objects) to 0 (renaming) or 1 (non-renaming)
2) the structure of the expression e *)
type sub = var -> Tot exp
type renaming (s:sub) = (forall (x:var). EVar? (s x))
val is_renaming : s:sub -> GTot (n:int{ (renaming s ==> n=0) /\
(~(renaming s) ==> n=1)})
let is_renaming s = (if strong_excluded_middle (renaming s) then 0 else 1)
val sub_inc : var -> Tot exp
let sub_inc y = EVar (y+1)
val renaming_sub_inc : unit -> Lemma (renaming (sub_inc))
let renaming_sub_inc _ = ()
let is_var (e:exp) : int = if EVar? e then 0 else 1
val sub_elam: s:sub -> var -> Tot (e:exp{renaming s ==> EVar? e})
(decreases %[1;is_renaming s; 0; EVar 0])
val subst : s:sub -> e:exp -> Pure exp (requires True)
(ensures (fun e' -> (renaming s /\ EVar? e) ==> EVar? e'))
(decreases %[is_var e; is_renaming s; 1; e])
let rec subst s e =
match e with
| EVar x -> s x
| ELam t e1 -> ELam t (subst (sub_elam s) e1)
| EApp e1 e2 -> EApp (subst s e1) (subst s e2)
| EUnit -> EUnit
and sub_elam s y = if y=0 then EVar y
else subst sub_inc (s (y-1))
val sub_beta : exp -> Tot sub
let sub_beta v = fun y -> if y = 0 then v (* substitute *)
else (EVar (y-1)) (* shift -1 *)
(* Small-step operational semantics; strong / full-beta reduction is
non-deterministic, so necessarily as inductive relation *)
type step : exp -> exp -> Type =
| SBeta : t:typ ->
e1:exp ->
e2:exp ->
step (EApp (ELam t e1) e2) (subst (sub_beta e2) e1)
| SApp1 : #e1:exp ->
e2:exp ->
#e1':exp ->
$hst:step e1 e1' ->
step (EApp e1 e2) (EApp e1' e2)
| SApp2 : e1:exp ->
#e2:exp ->
#e2':exp ->
$hst:step e2 e2' ->
step (EApp e1 e2) (EApp e1 e2')
(* Type system; as inductive relation (not strictly necessary for STLC) *)
type env = var -> Tot (option typ)
val empty : env
let empty _ = None
(* we only need extend at 0 *) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Constructive.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "StlcStrongDbParSubst.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.StrongExcludedMiddle",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Constructive",
"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 | t: StlcStrongDbParSubst.typ -> g: StlcStrongDbParSubst.env -> StlcStrongDbParSubst.env | Prims.Tot | [
"total"
] | [] | [
"StlcStrongDbParSubst.typ",
"StlcStrongDbParSubst.env",
"StlcStrongDbParSubst.var",
"Prims.op_Equality",
"Prims.int",
"FStar.Pervasives.Native.Some",
"Prims.bool",
"Prims.op_Subtraction",
"FStar.Pervasives.Native.option"
] | [] | false | false | false | true | false | let extend t g y =
| if y = 0 then Some t else g (y - 1) | false |
StlcStrongDbParSubst.fst | StlcStrongDbParSubst.sub_beta | val sub_beta : exp -> Tot sub | val sub_beta : exp -> Tot sub | let sub_beta v = fun y -> if y = 0 then v (* substitute *)
else (EVar (y-1)) | {
"file_name": "examples/metatheory/StlcStrongDbParSubst.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 43,
"end_line": 87,
"start_col": 0,
"start_line": 86
} | (*
Copyright 2014-2015
Simon Forest - Inria and ENS Paris
Catalin Hritcu - Inria
Nikhil Swamy - 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 StlcStrongDbParSubst
open FStar.Constructive
open FStar.Classical
open FStar.FunctionalExtensionality
open FStar.StrongExcludedMiddle
(* Constructive-style progress and preservation proof for STLC with
strong reduction, using deBruijn indices and parallel substitution. *)
type typ =
| TArr : typ -> typ -> typ
| TUnit : typ
type var = nat
type exp =
| EVar : var -> exp
| EApp : exp -> exp -> exp
| ELam : typ -> exp -> exp
| EUnit : exp
(* Parallel substitution operation `subst` *)
(* The termination argument uses a lexicographic ordering composed of:
0) a bit saying whether the expression is a variable or not;
1) an _undecidable_ well-founded order on substitutions that
equates all renamings, equates all non-renamings, and makes
renamings strictly smaller than non-renamings; we write down a
non-constructive function is_renaming mapping substitutions
(infinite objects) to 0 (renaming) or 1 (non-renaming)
2) the structure of the expression e *)
type sub = var -> Tot exp
type renaming (s:sub) = (forall (x:var). EVar? (s x))
val is_renaming : s:sub -> GTot (n:int{ (renaming s ==> n=0) /\
(~(renaming s) ==> n=1)})
let is_renaming s = (if strong_excluded_middle (renaming s) then 0 else 1)
val sub_inc : var -> Tot exp
let sub_inc y = EVar (y+1)
val renaming_sub_inc : unit -> Lemma (renaming (sub_inc))
let renaming_sub_inc _ = ()
let is_var (e:exp) : int = if EVar? e then 0 else 1
val sub_elam: s:sub -> var -> Tot (e:exp{renaming s ==> EVar? e})
(decreases %[1;is_renaming s; 0; EVar 0])
val subst : s:sub -> e:exp -> Pure exp (requires True)
(ensures (fun e' -> (renaming s /\ EVar? e) ==> EVar? e'))
(decreases %[is_var e; is_renaming s; 1; e])
let rec subst s e =
match e with
| EVar x -> s x
| ELam t e1 -> ELam t (subst (sub_elam s) e1)
| EApp e1 e2 -> EApp (subst s e1) (subst s e2)
| EUnit -> EUnit
and sub_elam s y = if y=0 then EVar y
else subst sub_inc (s (y-1)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Constructive.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "StlcStrongDbParSubst.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.StrongExcludedMiddle",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Constructive",
"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 | v: StlcStrongDbParSubst.exp -> StlcStrongDbParSubst.sub | Prims.Tot | [
"total"
] | [] | [
"StlcStrongDbParSubst.exp",
"StlcStrongDbParSubst.var",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"StlcStrongDbParSubst.EVar",
"Prims.op_Subtraction"
] | [] | false | false | false | true | false | let sub_beta v =
| fun y -> if y = 0 then v else (EVar (y - 1)) | false |
PulseCore.Action.fst | PulseCore.Action.elim_exists | val elim_exists (#a:Type u#a) (p:a -> slprop)
: act (erased a) emp_inames (exists* x. p x) (fun x -> p x) | val elim_exists (#a:Type u#a) (p:a -> slprop)
: act (erased a) emp_inames (exists* x. p x) (fun x -> p x) | let elim_exists (#a:Type u#a) (p:a -> slprop)
: act (erased a) emp_inames (exists* x. p x) (fun x -> p x)
= coerce_eq (exists_equiv #a #p) (elim_exists' #a p) | {
"file_name": "lib/pulse_core/PulseCore.Action.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 52,
"end_line": 378,
"start_col": 0,
"start_line": 376
} | module PulseCore.Action
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module I = PulseCore.InstantiatedSemantics
module M = PulseCore.MonotonicStateMonad
module F = FStar.FunctionalExtensionality
friend PulseCore.InstantiatedSemantics
open FStar.PCM
open FStar.Ghost
open PulseCore.Memory
open PulseCore.InstantiatedSemantics
//////////////////////////////////////////////////////
// An abstraction on top of memory actions
//////////////////////////////////////////////////////
(* The type of atomic actions *)
let action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= frame:slprop ->
Sem.mst_sep_aux state
(inames_ok except)
(state0 except).invariant
a
(pre `star` frame)
(fun x -> post x `star` frame)
let return_action
(#a:Type u#a)
(#except:inames)
(#post:a -> slprop)
(x:a)
: action a except (post x) post
= fun frame -> M.weaken (M.return x)
let bind_action
(#a:Type u#a)
(#b:Type u#b)
(#except:inames)
(#pre1 #post1 #post2:_)
(f:action a except pre1 post1)
(g:(x:a -> action b except (post1 x) post2))
: action b except pre1 post2
= fun frame -> M.weaken (M.bind (f frame) (fun x -> g x frame))
let frame_action
(#a:Type u#a)
(#except:inames)
(#pre #post #frame:_)
(f:action a except pre post)
: action a except (pre `star` frame) (fun x -> post x `star` frame)
= fun frame' -> f (frame `star` frame')
let stt_of_action (#a:Type u#100) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
let m : Sem.m a pre _ = Sem.act action in
fun _ -> m
let stt_of_action0 (#a:Type u#0) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m0 action
let stt_of_action1 (#a:Type u#1) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m1 u#2 u#100 action
let stt_of_action2 (#a:Type u#2) #pre #post (m:action a Set.empty pre post)
: stt a pre post
= let step (frame:slprop)
: Sem.mst_sep state a (pre `star` frame) (fun x -> post x `star` frame)
= M.weaken (m frame)
in
let action : Sem.action state a = {pre=pre; post=F.on_dom _ post; step} in
fun _ -> Sem.act_as_m2 u#2 u#100 action
let mem_action_as_action
(a:Type u#a)
(except:inames)
(req:slprop)
(ens: a -> slprop)
(act:Mem.action_except a except req ens)
: action a except req ens
= fun frame ->
let thunk
: unit -> MstTot a except req ens frame
= fun _ -> act frame
in
M.of_msttotal _ _ _ _ thunk
let action_as_mem_action
(a:Type u#a)
(except:inames)
(pre:slprop)
(post: a -> slprop)
(act:action a except pre post)
: Mem.action_except a except pre post
= fun frame ->
let m
: M.mst state.evolves
a
(fun s0 ->
inames_ok except s0 /\
interp ((pre `star` locks_invariant except s0) `star` frame) s0)
(fun s0 x s1 ->
inames_ok except s1 /\
interp ((post x `star` locks_invariant except s1) `star` frame) s1)
= M.weaken (act frame)
in
M.to_msttotal _ _ _ _ m
//////////////////////////////////////////////////////
// Next, reversing the polarity of the inames index
//////////////////////////////////////////////////////
let iname = iname
let act
(a:Type u#a)
(opens:inames)
(pre:slprop)
(post:a -> slprop)
: Type u#(max a 2)
= #ictx:inames_disj opens ->
action a ictx pre post
let return
(#a:Type u#a)
(#post:a -> slprop)
(x:a)
: act a emp_inames (post x) post
= fun #ictx -> return_action #a #ictx #post x
let bind
(#a:Type u#a)
(#b:Type u#b)
(#opens:inames)
(#pre1 #post1 #post2:_)
(f:act a opens pre1 post1)
(g:(x:a -> act b opens (post1 x) post2))
: act b opens pre1 post2
= fun #ictx -> bind_action #a #b #ictx #pre1 #post1 #post2 (f #ictx) (fun x -> g x #ictx)
let frame
(#a:Type u#a)
(#opens:inames)
(#pre #post #frame:_)
(f:act a opens pre post)
: act a opens (pre `star` frame) (fun x -> post x `star` frame)
= fun #ictx -> frame_action (f #ictx)
let weaken
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens opens':inames)
(f:act a opens pre post)
: act a (Set.union opens opens') pre post
= f
let sub
(#a:Type)
(#pre:slprop)
(#post:a -> slprop)
(#opens:inames)
(pre':slprop { slprop_equiv pre pre' })
(post':a -> slprop { forall x. slprop_equiv (post x) (post' x) })
(f:act a opens pre post)
: act a opens pre' post'
= I.slprop_equiv_elim pre pre';
introduce forall x. post x == post' x
with I.slprop_equiv_elim (post x) (post' x);
f
let lift (#a:Type u#100) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action (m #emp_inames)
let lift0 (#a:Type u#0) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action0 (m #emp_inames)
let lift1 (#a:Type u#1) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action1 (m #emp_inames)
let lift2 (#a:Type u#2) #opens #pre #post
(m:act a opens pre post)
: stt a pre post
= stt_of_action2 (m #emp_inames)
///////////////////////////////////////////////////////
// invariants
///////////////////////////////////////////////////////
let inv = inv
let name_of_inv = name_of_inv
let new_invariant (p:slprop)
: act (inv p) emp_inames p (fun _ -> emp)
= fun #ictx ->
mem_action_as_action _ _ _ _ (new_invariant ictx p)
let with_invariant
(#a:Type)
(#fp:slprop)
(#fp':a -> slprop)
(#f_opens:inames)
(#p:slprop)
(i:inv p{not (mem_inv f_opens i)})
(f:unit -> act a f_opens (p `star` fp) (fun x -> p `star` fp' x))
: act a (add_inv f_opens i) fp fp'
= fun #ictx ->
let ictx' = Mem.add_inv ictx i in
let f = action_as_mem_action _ _ _ _ (f () #ictx') in
let m = with_invariant i f in
mem_action_as_action _ _ _ _ m
///////////////////////////////////////////////////////////////////
// Core operations on references
///////////////////////////////////////////////////////////////////
let ref (a:Type u#a) (p:pcm a) = ref a p
let ref_null (#a:Type u#a) (p:pcm a) = core_ref_null
let is_ref_null (#a:Type u#a) (#p:pcm a) (r:ref a p) = core_ref_is_null r
let pts_to = pts_to
let pts_to_not_null #a #p r v =
fun #ictx -> mem_action_as_action _ _ _ _ (pts_to_not_null_action ictx r v)
let alloc
(#a:Type u#1)
(#pcm:pcm a)
(x:a{compatible pcm x x /\ pcm.refine x})
: act (ref a pcm) emp_inames emp (fun r -> pts_to r x)
= fun #ictx ->
mem_action_as_action _ _ _ _
(alloc_action ictx x)
let read
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x:erased a)
(f:(v:a{compatible p x v}
-> GTot (y:a{compatible p y v /\
FStar.PCM.frame_compatible p x v y})))
: act (v:a{compatible p x v /\ p.refine v}) emp_inames
(pts_to r x)
(fun v -> pts_to r (f v))
= fun #ictx ->
mem_action_as_action _ _ _ _ (select_refine ictx r x f)
let write
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x y:Ghost.erased a)
(f:FStar.PCM.frame_preserving_upd p x y)
: act unit emp_inames
(pts_to r x)
(fun _ -> pts_to r y)
= fun #ictx -> mem_action_as_action _ _ _ _ (upd_gen ictx r x y f)
let share
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a{composable pcm v0 v1})
: act unit emp_inames
(pts_to r (v0 `op pcm` v1))
(fun _ -> pts_to r v0 `star` pts_to r v1)
= fun #ictx -> mem_action_as_action _ _ _ _ (split_action ictx r v0 v1)
let gather
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:FStar.Ghost.erased a)
(v1:FStar.Ghost.erased a)
: act (squash (composable pcm v0 v1))
emp_inames
(pts_to r v0 `star` pts_to r v1)
(fun _ -> pts_to r (op pcm v0 v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (gather_action ictx r v0 v1)
let witnessed = witnessed
let witness
(#a:Type)
(#pcm:pcm a)
(r:erased (ref a pcm))
(fact:stable_property pcm)
(v:Ghost.erased a)
(pf:squash (forall z. compatible pcm v z ==> fact z))
: act (witnessed r fact) emp_inames (pts_to r v) (fun _ -> pts_to r v)
= fun #ictx -> mem_action_as_action _ _ _ _ (witness ictx r fact v pf)
let recall
(#a:Type u#1)
(#pcm:pcm a)
(#fact:property a)
(r:erased (ref a pcm))
(v:Ghost.erased a)
(w:witnessed r fact)
: act (v1:Ghost.erased a{compatible pcm v v1})
emp_inames
(pts_to r v)
(fun v1 -> pts_to r v `star` pure (fact v1))
= fun #ictx -> mem_action_as_action _ _ _ _ (recall ictx r v w)
///////////////////////////////////////////////////////////////////
// pure
///////////////////////////////////////////////////////////////////
let pure_true ()
= Mem.pure_true_emp ();
slprop_equiv_elim (pure True) emp;
coerce_eq () <| slprop_equiv_refl (pure True)
let intro_pure (p:prop) (pf:squash p)
: act unit emp_inames emp (fun _ -> pure p)
= fun #ictx -> mem_action_as_action _ _ _ _ (intro_pure #ictx p pf)
let elim_pure (p:prop)
: act (squash p) emp_inames (pure p) (fun _ -> emp)
= fun #ictx -> mem_action_as_action _ _ _ _ (elim_pure #ictx p)
///////////////////////////////////////////////////////////////////
// exists*
///////////////////////////////////////////////////////////////////
module F = FStar.FunctionalExtensionality
let exists_equiv (#a:_) (#p:a -> slprop)
: squash (op_exists_Star p == (exists* x. p x))
= let pf = I.slprop_equiv_exists p (fun x -> p x) () in
let pf = FStar.Squash.return_squash pf in
I.slprop_equiv_elim (op_exists_Star p) (exists* x. p x)
let thunk (p:slprop) = fun (_:unit) -> p
let intro_exists' (#a:Type u#a) (p:a -> slprop) (x:erased a)
: act unit emp_inames (p x) (thunk (op_exists_Star p))
= fun #ictx -> mem_action_as_action _ _ _ _ (intro_exists #ictx (F.on_dom a p) x)
let intro_exists'' (#a:Type u#a) (p:a -> slprop) (x:erased a)
: act unit emp_inames (p x) (thunk (exists* x. p x))
= coerce_eq (exists_equiv #a #p) (intro_exists' #a p x)
let intro_exists (#a:Type u#a) (p:a -> slprop) (x:erased a)
: act unit emp_inames (p x) (fun _ -> exists* x. p x)
= intro_exists'' p x
let elim_exists' (#a:Type u#a) (p:a -> slprop)
: act (erased a) emp_inames (op_exists_Star p) (fun x -> p x)
= fun #ictx -> mem_action_as_action _ _ _ _ (witness_h_exists #ictx (F.on_dom a p)) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"PulseCore.Memory.fsti.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"PulseCore.InstantiatedSemantics.fst.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.Action.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "PulseCore.Preorder",
"short_module": "PP"
},
{
"abbrev": true,
"full_module": "PulseCore.InstantiatedSemantics",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: (_: a -> PulseCore.InstantiatedSemantics.slprop)
-> PulseCore.Action.act (FStar.Ghost.erased a)
PulseCore.Action.emp_inames
(exists* (x: a). p x)
(fun x -> p (FStar.Ghost.reveal x)) | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"FStar.Pervasives.coerce_eq",
"PulseCore.Action.act",
"FStar.Ghost.erased",
"PulseCore.Action.emp_inames",
"PulseCore.InstantiatedSemantics.op_exists_Star",
"FStar.Ghost.reveal",
"PulseCore.Action.exists_equiv",
"PulseCore.Action.elim_exists'"
] | [] | false | false | false | false | false | let elim_exists (#a: Type u#a) (p: (a -> slprop))
: act (erased a) emp_inames (exists* x. p x) (fun x -> p x) =
| coerce_eq (exists_equiv #a #p) (elim_exists' #a p) | false |
StlcStrongDbParSubst.fst | StlcStrongDbParSubst.progress | val progress : #e:exp -> #t:typ -> h:typing empty e t ->
Pure (cexists (fun e' -> step e e'))
(requires (~ (is_value e)))
(ensures (fun _ -> True)) (decreases h) | val progress : #e:exp -> #t:typ -> h:typing empty e t ->
Pure (cexists (fun e' -> step e e'))
(requires (~ (is_value e)))
(ensures (fun _ -> True)) (decreases h) | let rec progress #e #t h =
match h with
| TyApp #g #e1 #e2 #t11 #t12 h1 h2 ->
match e1 with
| ELam t e1' -> ExIntro (subst (sub_beta e2) e1') (SBeta t e1' e2)
| _ -> let ExIntro e1' h1' = progress h1 in
ExIntro (EApp e1' e2) (SApp1 e2 h1') | {
"file_name": "examples/metatheory/StlcStrongDbParSubst.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 57,
"end_line": 156,
"start_col": 0,
"start_line": 150
} | (*
Copyright 2014-2015
Simon Forest - Inria and ENS Paris
Catalin Hritcu - Inria
Nikhil Swamy - 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 StlcStrongDbParSubst
open FStar.Constructive
open FStar.Classical
open FStar.FunctionalExtensionality
open FStar.StrongExcludedMiddle
(* Constructive-style progress and preservation proof for STLC with
strong reduction, using deBruijn indices and parallel substitution. *)
type typ =
| TArr : typ -> typ -> typ
| TUnit : typ
type var = nat
type exp =
| EVar : var -> exp
| EApp : exp -> exp -> exp
| ELam : typ -> exp -> exp
| EUnit : exp
(* Parallel substitution operation `subst` *)
(* The termination argument uses a lexicographic ordering composed of:
0) a bit saying whether the expression is a variable or not;
1) an _undecidable_ well-founded order on substitutions that
equates all renamings, equates all non-renamings, and makes
renamings strictly smaller than non-renamings; we write down a
non-constructive function is_renaming mapping substitutions
(infinite objects) to 0 (renaming) or 1 (non-renaming)
2) the structure of the expression e *)
type sub = var -> Tot exp
type renaming (s:sub) = (forall (x:var). EVar? (s x))
val is_renaming : s:sub -> GTot (n:int{ (renaming s ==> n=0) /\
(~(renaming s) ==> n=1)})
let is_renaming s = (if strong_excluded_middle (renaming s) then 0 else 1)
val sub_inc : var -> Tot exp
let sub_inc y = EVar (y+1)
val renaming_sub_inc : unit -> Lemma (renaming (sub_inc))
let renaming_sub_inc _ = ()
let is_var (e:exp) : int = if EVar? e then 0 else 1
val sub_elam: s:sub -> var -> Tot (e:exp{renaming s ==> EVar? e})
(decreases %[1;is_renaming s; 0; EVar 0])
val subst : s:sub -> e:exp -> Pure exp (requires True)
(ensures (fun e' -> (renaming s /\ EVar? e) ==> EVar? e'))
(decreases %[is_var e; is_renaming s; 1; e])
let rec subst s e =
match e with
| EVar x -> s x
| ELam t e1 -> ELam t (subst (sub_elam s) e1)
| EApp e1 e2 -> EApp (subst s e1) (subst s e2)
| EUnit -> EUnit
and sub_elam s y = if y=0 then EVar y
else subst sub_inc (s (y-1))
val sub_beta : exp -> Tot sub
let sub_beta v = fun y -> if y = 0 then v (* substitute *)
else (EVar (y-1)) (* shift -1 *)
(* Small-step operational semantics; strong / full-beta reduction is
non-deterministic, so necessarily as inductive relation *)
type step : exp -> exp -> Type =
| SBeta : t:typ ->
e1:exp ->
e2:exp ->
step (EApp (ELam t e1) e2) (subst (sub_beta e2) e1)
| SApp1 : #e1:exp ->
e2:exp ->
#e1':exp ->
$hst:step e1 e1' ->
step (EApp e1 e2) (EApp e1' e2)
| SApp2 : e1:exp ->
#e2:exp ->
#e2':exp ->
$hst:step e2 e2' ->
step (EApp e1 e2) (EApp e1 e2')
(* Type system; as inductive relation (not strictly necessary for STLC) *)
type env = var -> Tot (option typ)
val empty : env
let empty _ = None
(* we only need extend at 0 *)
val extend : typ -> env -> Tot env
let extend t g y = if y = 0 then Some t
else g (y-1)
noeq type typing : env -> exp -> typ -> Type =
| TyVar : #g:env ->
x:var{Some? (g x)} ->
typing g (EVar x) (Some?.v (g x))
| TyLam : #g :env ->
t :typ ->
#e1:exp ->
#t':typ ->
$hbody:typing (extend t g) e1 t' ->
typing g (ELam t e1) (TArr t t')
| TyApp : #g:env ->
#e1:exp ->
#e2:exp ->
#t11:typ ->
#t12:typ ->
$h1:typing g e1 (TArr t11 t12) ->
$h2:typing g e2 t11 ->
typing g (EApp e1 e2) t12
| TyUnit : #g:env ->
typing g EUnit TUnit
(* Progress *)
val is_value : exp -> Tot bool
let is_value e = ELam? e || EUnit? e
val progress : #e:exp -> #t:typ -> h:typing empty e t ->
Pure (cexists (fun e' -> step e e'))
(requires (~ (is_value e))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Constructive.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "StlcStrongDbParSubst.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.StrongExcludedMiddle",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Constructive",
"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: StlcStrongDbParSubst.typing StlcStrongDbParSubst.empty e t
-> Prims.Pure (FStar.Constructive.cexists (fun e' -> StlcStrongDbParSubst.step e e')) | Prims.Pure | [
""
] | [] | [
"StlcStrongDbParSubst.exp",
"StlcStrongDbParSubst.typ",
"StlcStrongDbParSubst.typing",
"StlcStrongDbParSubst.empty",
"StlcStrongDbParSubst.env",
"StlcStrongDbParSubst.TArr",
"FStar.Constructive.ExIntro",
"StlcStrongDbParSubst.step",
"StlcStrongDbParSubst.subst",
"StlcStrongDbParSubst.sub_beta",
"StlcStrongDbParSubst.SBeta",
"StlcStrongDbParSubst.EApp",
"StlcStrongDbParSubst.SApp1",
"FStar.Constructive.cexists",
"StlcStrongDbParSubst.progress"
] | [
"recursion"
] | false | false | false | false | false | let rec progress #e #t h =
| match h with
| TyApp #g #e1 #e2 #t11 #t12 h1 h2 ->
match e1 with
| ELam t e1' -> ExIntro (subst (sub_beta e2) e1') (SBeta t e1' e2)
| _ ->
let ExIntro e1' h1' = progress h1 in
ExIntro (EApp e1' e2) (SApp1 e2 h1') | false |
StlcStrongDbParSubst.fst | StlcStrongDbParSubst.preservation | val preservation : #e:exp -> #e':exp -> #g:env -> #t:typ ->
ht:(typing g e t) ->
hs:step e e' ->
Tot (typing g e' t) (decreases ht) | val preservation : #e:exp -> #e':exp -> #g:env -> #t:typ ->
ht:(typing g e t) ->
hs:step e e' ->
Tot (typing g e' t) (decreases ht) | let rec preservation #e #e' #g #t (TyApp h1 h2) hs =
match hs with
| SBeta tx e1' e2' -> substitution_beta h2 (TyLam?.hbody h1)
| SApp1 e2' hs1 -> TyApp (preservation h1 hs1) h2
| SApp2 e1' hs2 -> TyApp h1 (preservation h2 hs2) | {
"file_name": "examples/metatheory/StlcStrongDbParSubst.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 53,
"end_line": 224,
"start_col": 0,
"start_line": 220
} | (*
Copyright 2014-2015
Simon Forest - Inria and ENS Paris
Catalin Hritcu - Inria
Nikhil Swamy - 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 StlcStrongDbParSubst
open FStar.Constructive
open FStar.Classical
open FStar.FunctionalExtensionality
open FStar.StrongExcludedMiddle
(* Constructive-style progress and preservation proof for STLC with
strong reduction, using deBruijn indices and parallel substitution. *)
type typ =
| TArr : typ -> typ -> typ
| TUnit : typ
type var = nat
type exp =
| EVar : var -> exp
| EApp : exp -> exp -> exp
| ELam : typ -> exp -> exp
| EUnit : exp
(* Parallel substitution operation `subst` *)
(* The termination argument uses a lexicographic ordering composed of:
0) a bit saying whether the expression is a variable or not;
1) an _undecidable_ well-founded order on substitutions that
equates all renamings, equates all non-renamings, and makes
renamings strictly smaller than non-renamings; we write down a
non-constructive function is_renaming mapping substitutions
(infinite objects) to 0 (renaming) or 1 (non-renaming)
2) the structure of the expression e *)
type sub = var -> Tot exp
type renaming (s:sub) = (forall (x:var). EVar? (s x))
val is_renaming : s:sub -> GTot (n:int{ (renaming s ==> n=0) /\
(~(renaming s) ==> n=1)})
let is_renaming s = (if strong_excluded_middle (renaming s) then 0 else 1)
val sub_inc : var -> Tot exp
let sub_inc y = EVar (y+1)
val renaming_sub_inc : unit -> Lemma (renaming (sub_inc))
let renaming_sub_inc _ = ()
let is_var (e:exp) : int = if EVar? e then 0 else 1
val sub_elam: s:sub -> var -> Tot (e:exp{renaming s ==> EVar? e})
(decreases %[1;is_renaming s; 0; EVar 0])
val subst : s:sub -> e:exp -> Pure exp (requires True)
(ensures (fun e' -> (renaming s /\ EVar? e) ==> EVar? e'))
(decreases %[is_var e; is_renaming s; 1; e])
let rec subst s e =
match e with
| EVar x -> s x
| ELam t e1 -> ELam t (subst (sub_elam s) e1)
| EApp e1 e2 -> EApp (subst s e1) (subst s e2)
| EUnit -> EUnit
and sub_elam s y = if y=0 then EVar y
else subst sub_inc (s (y-1))
val sub_beta : exp -> Tot sub
let sub_beta v = fun y -> if y = 0 then v (* substitute *)
else (EVar (y-1)) (* shift -1 *)
(* Small-step operational semantics; strong / full-beta reduction is
non-deterministic, so necessarily as inductive relation *)
type step : exp -> exp -> Type =
| SBeta : t:typ ->
e1:exp ->
e2:exp ->
step (EApp (ELam t e1) e2) (subst (sub_beta e2) e1)
| SApp1 : #e1:exp ->
e2:exp ->
#e1':exp ->
$hst:step e1 e1' ->
step (EApp e1 e2) (EApp e1' e2)
| SApp2 : e1:exp ->
#e2:exp ->
#e2':exp ->
$hst:step e2 e2' ->
step (EApp e1 e2) (EApp e1 e2')
(* Type system; as inductive relation (not strictly necessary for STLC) *)
type env = var -> Tot (option typ)
val empty : env
let empty _ = None
(* we only need extend at 0 *)
val extend : typ -> env -> Tot env
let extend t g y = if y = 0 then Some t
else g (y-1)
noeq type typing : env -> exp -> typ -> Type =
| TyVar : #g:env ->
x:var{Some? (g x)} ->
typing g (EVar x) (Some?.v (g x))
| TyLam : #g :env ->
t :typ ->
#e1:exp ->
#t':typ ->
$hbody:typing (extend t g) e1 t' ->
typing g (ELam t e1) (TArr t t')
| TyApp : #g:env ->
#e1:exp ->
#e2:exp ->
#t11:typ ->
#t12:typ ->
$h1:typing g e1 (TArr t11 t12) ->
$h2:typing g e2 t11 ->
typing g (EApp e1 e2) t12
| TyUnit : #g:env ->
typing g EUnit TUnit
(* Progress *)
val is_value : exp -> Tot bool
let is_value e = ELam? e || EUnit? e
val progress : #e:exp -> #t:typ -> h:typing empty e t ->
Pure (cexists (fun e' -> step e e'))
(requires (~ (is_value e)))
(ensures (fun _ -> True)) (decreases h)
let rec progress #e #t h =
match h with
| TyApp #g #e1 #e2 #t11 #t12 h1 h2 ->
match e1 with
| ELam t e1' -> ExIntro (subst (sub_beta e2) e1') (SBeta t e1' e2)
| _ -> let ExIntro e1' h1' = progress h1 in
ExIntro (EApp e1' e2) (SApp1 e2 h1')
module T = FStar.Tactics.V2
(* Substitution extensional - used by substitution lemma below *)
val subst_extensional: s1:sub -> s2:sub{feq s1 s2} -> e:exp ->
Lemma (requires True)
(ensures (subst s1 e = subst s2 e))
[SMTPat (subst s1 e); SMTPat (subst s2 e)]
let rec subst_extensional s1 s2 e =
match e with
| EVar _ -> ()
| ELam t e1 ->
assert (subst s1 (ELam t e1) == ELam t (subst (sub_elam s1) e1))
by T.norm [zeta; iota; delta_only [`%subst]];
assert (subst s2 (ELam t e1) == ELam t (subst (sub_elam s2) e1))
by T.norm [zeta; iota; delta_only [`%subst]];
subst_extensional (sub_elam s1) (sub_elam s2) e1
| EApp e1 e2 -> subst_extensional s1 s2 e1; subst_extensional s1 s2 e2
| _ -> ()
(* Typing of substitutions (very easy, actually) *)
type subst_typing (s:sub) (g1:env) (g2:env) =
(x:var{Some? (g1 x)} -> Tot(typing g2 (s x) (Some?.v (g1 x))))
(* Substitution preserves typing
Strongest possible statement; suggested by Steven Schäfer *)
val substitution :
#g1:env -> #e:exp -> #t:typ -> s:sub -> #g2:env ->
h1:typing g1 e t ->
hs:subst_typing s g1 g2 ->
Tot (typing g2 (subst s e) t)
(decreases %[is_var e; is_renaming s; e])
let rec substitution #g1 #e #t s #g2 h1 hs =
match h1 with
| TyVar x -> hs x
| TyApp hfun harg -> TyApp (substitution s hfun hs) (substitution s harg hs)
| TyLam tlam hbody ->
let hs'' : subst_typing (sub_inc) g2 (extend tlam g2) =
fun x -> TyVar (x+1) in
let hs' : subst_typing (sub_elam s) (extend tlam g1) (extend tlam g2) =
fun y -> if y = 0 then TyVar y
else let n:var = y - 1 in //Silly limitation of implicits and refinements
substitution sub_inc (hs n) hs'' //NS: needed to instantiate the Some?.v
in TyLam tlam (substitution (sub_elam s) hbody hs')
| TyUnit -> TyUnit
(* Substitution for beta reduction
Now just a special case of substitution lemma *)
val substitution_beta :
#e:exp -> #v:exp -> #t_x:typ -> #t:typ -> #g:env ->
h1:typing g v t_x ->
h2:typing (extend t_x g) e t ->
Tot (typing g (subst (sub_beta v) e) t) (decreases e)
let rec substitution_beta #e #v #t_x #t #g h1 h2 =
let hs : subst_typing (sub_beta v) (extend t_x g) g =
fun y -> if y = 0 then h1 else TyVar (y-1) in
substitution (sub_beta v) h2 hs
(* Type preservation *)
val preservation : #e:exp -> #e':exp -> #g:env -> #t:typ ->
ht:(typing g e t) ->
hs:step e e' -> | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Constructive.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "StlcStrongDbParSubst.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.StrongExcludedMiddle",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Constructive",
"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 | ht: StlcStrongDbParSubst.typing g e t -> hs: StlcStrongDbParSubst.step e e'
-> Prims.Tot (StlcStrongDbParSubst.typing g e' t) | Prims.Tot | [
"total",
""
] | [] | [
"StlcStrongDbParSubst.exp",
"StlcStrongDbParSubst.env",
"StlcStrongDbParSubst.typ",
"StlcStrongDbParSubst.typing",
"StlcStrongDbParSubst.step",
"StlcStrongDbParSubst.TArr",
"StlcStrongDbParSubst.substitution_beta",
"StlcStrongDbParSubst.__proj__TyLam__item__e1",
"StlcStrongDbParSubst.__proj__TyLam__item__t'",
"StlcStrongDbParSubst.__proj__TyLam__item__hbody",
"StlcStrongDbParSubst.TyApp",
"StlcStrongDbParSubst.preservation"
] | [
"recursion"
] | false | false | false | false | false | let rec preservation #e #e' #g #t (TyApp h1 h2) hs =
| match hs with
| SBeta tx e1' e2' -> substitution_beta h2 (TyLam?.hbody h1)
| SApp1 e2' hs1 -> TyApp (preservation h1 hs1) h2
| SApp2 e1' hs2 -> TyApp h1 (preservation h2 hs2) | false |
Vale.Curve25519.X64.FastUtil.fsti | Vale.Curve25519.X64.FastUtil.va_wp_Cswap2 | val va_wp_Cswap2
(bit_in: nat64)
(p0_b p1_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Cswap2
(bit_in: nat64)
(p0_b p1_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Cswap2 (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0
(va_get_mem va_s0) in let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
1 (va_get_mem va_s0) in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 2 (va_get_mem va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_s0) in let
(old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in
let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0)
in let (old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem
va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0
(va_get_mem va_s0) in let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
1 (va_get_mem va_s0) in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 2 (va_get_mem va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_s0) in let
(old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in
let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0)
in let (old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem
va_s0) in Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
bit_in == va_get_reg64 rRdi va_s0 /\ va_get_reg64 rRdi va_s0 <= 1 /\
(Vale.X64.Decls.buffers_disjoint p1_b p0_b \/ p1_b == p0_b) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) p0_b 8 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) p1_b 8
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rdi:nat64)
(va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) . let va_sM = va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags va_x_efl (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdi va_x_rdi
(va_upd_mem va_x_mem va_s0))))))) in va_get_ok va_sM /\ (let (old_p0_0:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in let
(old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0) in
let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_s0)
in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem
va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 4
(va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in let
(old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0) in
let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_s0)
in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem
va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 4
(va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in Vale.X64.Decls.modifies_buffer_2 p0_b
p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (let p0_0 = Vale.X64.Decls.buffer64_read p0_b 0
(va_get_mem va_sM) in let p0_1 = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let
p0_2 = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == va_if (va_get_reg64 rRdi
va_s0 = 1) (fun _ -> old_p1_0) (fun _ -> old_p0_0) /\ p0_1 == va_if (va_get_reg64 rRdi va_s0 =
1) (fun _ -> old_p1_1) (fun _ -> old_p0_1) /\ p0_2 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun
_ -> old_p1_2) (fun _ -> old_p0_2) /\ p0_3 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_3) (fun _ -> old_p0_3) /\ p0_4 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_4) (fun _ -> old_p0_4) /\ p0_5 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_5) (fun _ -> old_p0_5) /\ p0_6 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_6) (fun _ -> old_p0_6) /\ p0_7 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_7) (fun _ -> old_p0_7) /\ p1_0 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_0) (fun _ -> old_p1_0) /\ p1_1 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_1) (fun _ -> old_p1_1) /\ p1_2 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_2) (fun _ -> old_p1_2) /\ p1_3 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_3) (fun _ -> old_p1_3) /\ p1_4 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_4) (fun _ -> old_p1_4) /\ p1_5 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_5) (fun _ -> old_p1_5) /\ p1_6 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_6) (fun _ -> old_p1_6) /\ p1_7 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_7) (fun _ -> old_p1_7))) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.Curve25519.X64.FastUtil.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 57,
"end_line": 548,
"start_col": 0,
"start_line": 468
} | module Vale.Curve25519.X64.FastUtil
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Fast_add1
val va_code_Fast_add1 : va_dummy:unit -> Tot va_code
val va_codegen_success_Fast_add1 : va_dummy:unit -> Tot va_pbool
let va_req_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
: prop =
(va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0))
let va_ens_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1 va_b0 va_s0 dst_b inA_b inB /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fast_add1 : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
adx_enabled /\ bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0)
(va_get_mem va_s0) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rdx:nat64) (va_x_r8:nat64)
(va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64) (va_x_heap0:vale_heap)
(va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11
va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8
(va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) ==> va_k va_sM (())))
val va_wpProof_Fast_add1 : dst_b:buffer64 -> inA_b:buffer64 -> inB:nat64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_add1 dst_b inA_b inB va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_add1 ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) : (va_quickCode unit
(va_code_Fast_add1 ())) =
(va_QProc (va_code_Fast_add1 ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx;
va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fast_add1 dst_b inA_b inB) (va_wpProof_Fast_add1 dst_b
inA_b inB))
//--
//-- Fast_add1_stdcall
val va_code_Fast_add1_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fast_add1_stdcall : win:bool -> Tot va_pbool
let va_req_Fast_add1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) : prop =
(va_require_total va_b0 (va_code_Fast_add1_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret))
let va_ens_Fast_add1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1_stdcall va_b0 va_s0 win dst_b inA_b inB_in /\ va_ensure_total va_b0 va_s0 va_sM
va_fM /\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fast_add1_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_in:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_add1_stdcall win) va_s0 /\ va_get_ok va_s0 /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let a0 = Vale.X64.Decls.buffer64_read
inA_b 0 (va_get_mem va_s0) in let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0)
in let a2 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fast_add1_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_in:nat64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in =
va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rbx:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64) (va_x_rbp:nat64)
(va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64)
(va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let a0 =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) ==> va_k va_sM (())))
val va_wpProof_Fast_add1_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_in:nat64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_add1_stdcall win dst_b inA_b inB_in va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_add1_stdcall win)
([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags;
va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10;
va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi;
va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax;
va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_add1_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_in:nat64) :
(va_quickCode unit (va_code_Fast_add1_stdcall win)) =
(va_QProc (va_code_Fast_add1_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fast_add1_stdcall win dst_b inA_b
inB_in) (va_wpProof_Fast_add1_stdcall win dst_b inA_b inB_in))
//--
//-- Cswap2
val va_code_Cswap2 : va_dummy:unit -> Tot va_code
val va_codegen_success_Cswap2 : va_dummy:unit -> Tot va_pbool
let va_req_Cswap2 (va_b0:va_code) (va_s0:va_state) (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64) :
prop =
(va_require_total va_b0 (va_code_Cswap2 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in
let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0)
in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem
va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3
(va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in let
(old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in
let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0)
in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem
va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3
(va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ bit_in == va_get_reg64 rRdi va_s0 /\
va_get_reg64 rRdi va_s0 <= 1 /\ (Vale.X64.Decls.buffers_disjoint p1_b p0_b \/ p1_b == p0_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRsi va_s0) p0_b 8
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdx va_s0) p1_b 8 (va_get_mem_layout va_s0) Secret))
let va_ens_Cswap2 (va_b0:va_code) (va_s0:va_state) (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Cswap2 va_b0 va_s0 bit_in p0_b p1_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0
(va_get_mem va_s0) in let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
1 (va_get_mem va_s0) in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 2 (va_get_mem va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_s0) in let
(old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in
let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0)
in let (old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem
va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0
(va_get_mem va_s0) in let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
1 (va_get_mem va_s0) in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 2 (va_get_mem va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_s0) in let
(old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in
let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0)
in let (old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem
va_s0) in Vale.X64.Decls.modifies_buffer_2 p0_b p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\
(let p0_0 = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_sM) in let p0_1 =
Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let p0_2 =
Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == (if (va_get_reg64 rRdi va_s0
= 1) then old_p1_0 else old_p0_0) /\ p0_1 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_1
else old_p0_1) /\ p0_2 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_2 else old_p0_2) /\
p0_3 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_3 else old_p0_3) /\ p0_4 == (if
(va_get_reg64 rRdi va_s0 = 1) then old_p1_4 else old_p0_4) /\ p0_5 == (if (va_get_reg64 rRdi
va_s0 = 1) then old_p1_5 else old_p0_5) /\ p0_6 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p1_6 else old_p0_6) /\ p0_7 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_7 else
old_p0_7) /\ p1_0 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_0 else old_p1_0) /\ p1_1 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_1 else old_p1_1) /\ p1_2 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_2 else old_p1_2) /\ p1_3 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p0_3 else old_p1_3) /\ p1_4 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_4 else
old_p1_4) /\ p1_5 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_5 else old_p1_5) /\ p1_6 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_6 else old_p1_6) /\ p1_7 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_7 else old_p1_7))) /\ va_state_eq va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdi va_sM (va_update_ok
va_sM (va_update_mem va_sM va_s0))))))))))
val va_lemma_Cswap2 : va_b0:va_code -> va_s0:va_state -> bit_in:nat64 -> p0_b:buffer64 ->
p1_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Cswap2 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in
let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0)
in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem
va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3
(va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in let
(old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in
let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0)
in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem
va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3
(va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ bit_in == va_get_reg64 rRdi va_s0 /\
va_get_reg64 rRdi va_s0 <= 1 /\ (Vale.X64.Decls.buffers_disjoint p1_b p0_b \/ p1_b == p0_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRsi va_s0) p0_b 8
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdx va_s0) p1_b 8 (va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0)
in let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem
va_s0) in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2
(va_get_mem va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
3 (va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let
(old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in
let (old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0)
in let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem
va_s0) in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2
(va_get_mem va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
3 (va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let
(old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in
Vale.X64.Decls.modifies_buffer_2 p0_b p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (let p0_0 =
Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_sM) in let p0_1 =
Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let p0_2 =
Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == (if (va_get_reg64 rRdi va_s0
= 1) then old_p1_0 else old_p0_0) /\ p0_1 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_1
else old_p0_1) /\ p0_2 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_2 else old_p0_2) /\
p0_3 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_3 else old_p0_3) /\ p0_4 == (if
(va_get_reg64 rRdi va_s0 = 1) then old_p1_4 else old_p0_4) /\ p0_5 == (if (va_get_reg64 rRdi
va_s0 = 1) then old_p1_5 else old_p0_5) /\ p0_6 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p1_6 else old_p0_6) /\ p0_7 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_7 else
old_p0_7) /\ p1_0 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_0 else old_p1_0) /\ p1_1 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_1 else old_p1_1) /\ p1_2 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_2 else old_p1_2) /\ p1_3 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p0_3 else old_p1_3) /\ p1_4 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_4 else
old_p1_4) /\ p1_5 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_5 else old_p1_5) /\ p1_6 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_6 else old_p1_6) /\ p1_7 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_7 else old_p1_7))) /\ va_state_eq va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdi va_sM (va_update_ok
va_sM (va_update_mem va_sM va_s0))))))))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastUtil.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
bit_in: Vale.X64.Memory.nat64 ->
p0_b: Vale.X64.Memory.buffer64 ->
p1_b: Vale.X64.Memory.buffer64 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Memory.nat64",
"Vale.X64.Memory.buffer64",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.Memory.is_initial_heap",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Decls.va_get_mem",
"Prims.eq2",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRdi",
"Prims.op_LessThanOrEqual",
"Prims.l_or",
"Vale.X64.Decls.buffers_disjoint",
"Vale.X64.Decls.validDstAddrs64",
"Vale.X64.Machine_s.rRsi",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Decls.buffer64_read",
"Prims.l_Forall",
"Vale.X64.InsBasic.vale_heap",
"Vale.X64.Flags.t",
"Vale.Arch.HeapImpl.vale_heap_layout",
"Prims.l_imp",
"Vale.X64.Decls.modifies_buffer_2",
"Vale.X64.Decls.va_if",
"Prims.op_Equality",
"Prims.int",
"Prims.l_not",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_mem_layout",
"Vale.X64.Decls.va_upd_mem_heaplet",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_reg64",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Decls.va_upd_mem"
] | [] | false | false | false | true | true | let va_wp_Cswap2
(bit_in: nat64)
(p0_b p1_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_get_ok va_s0 /\
(let old_p0_0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in
let old_p0_1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0) in
let old_p0_2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_s0) in
let old_p0_3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0) in
let old_p0_4:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_s0) in
let old_p0_5:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in
let old_p0_6:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in
let old_p0_7:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in
let old_p1_0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in
let old_p1_1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0) in
let old_p1_2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_s0) in
let old_p1_3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0) in
let old_p1_4:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_s0) in
let old_p1_5:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in
let old_p1_6:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in
let old_p1_7:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
bit_in == va_get_reg64 rRdi va_s0 /\ va_get_reg64 rRdi va_s0 <= 1 /\
(Vale.X64.Decls.buffers_disjoint p1_b p0_b \/ p1_b == p0_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0)
p0_b
8
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdx va_s0)
p1_b
8
(va_get_mem_layout va_s0)
Secret) /\
(forall (va_x_mem: vale_heap)
(va_x_rdi: nat64)
(va_x_r8: nat64)
(va_x_r9: nat64)
(va_x_r10: nat64)
(va_x_efl: Vale.X64.Flags.t)
(va_x_heap0: vale_heap)
(va_x_memLayout: vale_heap_layout).
let va_sM =
va_upd_mem_layout va_x_memLayout
(va_upd_mem_heaplet 0
va_x_heap0
(va_upd_flags va_x_efl
(va_upd_reg64 rR10
va_x_r10
(va_upd_reg64 rR9
va_x_r9
(va_upd_reg64 rR8
va_x_r8
(va_upd_reg64 rRdi va_x_rdi (va_upd_mem va_x_mem va_s0)))))))
in
va_get_ok va_sM /\
(let old_p0_0:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0)
in
let old_p0_1:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0)
in
let old_p0_2:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_s0)
in
let old_p0_3:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0)
in
let old_p0_4:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_s0)
in
let old_p0_5:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0)
in
let old_p0_6:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0)
in
let old_p0_7:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0)
in
let old_p1_0:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0)
in
let old_p1_1:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0)
in
let old_p1_2:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_s0)
in
let old_p1_3:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0)
in
let old_p1_4:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_s0)
in
let old_p1_5:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0)
in
let old_p1_6:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0)
in
let old_p1_7:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0)
in
Vale.X64.Decls.modifies_buffer_2 p0_b p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\
(let p0_0 = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_sM) in
let p0_1 = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in
let p0_2 = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in
let p0_3 = Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in
let p0_4 = Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in
let p0_5 = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in
let p0_6 = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in
let p0_7 = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in
let p1_0 = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in
let p1_1 = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in
let p1_2 = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in
let p1_3 = Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in
let p1_4 = Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in
let p1_5 = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in
let p1_6 = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in
let p1_7 = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in
p0_0 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ -> old_p1_0) (fun _ -> old_p0_0) /\
p0_1 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ -> old_p1_1) (fun _ -> old_p0_1) /\
p0_2 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ -> old_p1_2) (fun _ -> old_p0_2) /\
p0_3 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ -> old_p1_3) (fun _ -> old_p0_3) /\
p0_4 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ -> old_p1_4) (fun _ -> old_p0_4) /\
p0_5 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ -> old_p1_5) (fun _ -> old_p0_5) /\
p0_6 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ -> old_p1_6) (fun _ -> old_p0_6) /\
p0_7 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ -> old_p1_7) (fun _ -> old_p0_7) /\
p1_0 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ -> old_p0_0) (fun _ -> old_p1_0) /\
p1_1 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ -> old_p0_1) (fun _ -> old_p1_1) /\
p1_2 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ -> old_p0_2) (fun _ -> old_p1_2) /\
p1_3 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ -> old_p0_3) (fun _ -> old_p1_3) /\
p1_4 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ -> old_p0_4) (fun _ -> old_p1_4) /\
p1_5 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ -> old_p0_5) (fun _ -> old_p1_5) /\
p1_6 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ -> old_p0_6) (fun _ -> old_p1_6) /\
p1_7 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ -> old_p0_7) (fun _ -> old_p1_7))) ==>
va_k va_sM (()))) | false |
StlcStrongDbParSubst.fst | StlcStrongDbParSubst.substitution_beta | val substitution_beta :
#e:exp -> #v:exp -> #t_x:typ -> #t:typ -> #g:env ->
h1:typing g v t_x ->
h2:typing (extend t_x g) e t ->
Tot (typing g (subst (sub_beta v) e) t) (decreases e) | val substitution_beta :
#e:exp -> #v:exp -> #t_x:typ -> #t:typ -> #g:env ->
h1:typing g v t_x ->
h2:typing (extend t_x g) e t ->
Tot (typing g (subst (sub_beta v) e) t) (decreases e) | let rec substitution_beta #e #v #t_x #t #g h1 h2 =
let hs : subst_typing (sub_beta v) (extend t_x g) g =
fun y -> if y = 0 then h1 else TyVar (y-1) in
substitution (sub_beta v) h2 hs | {
"file_name": "examples/metatheory/StlcStrongDbParSubst.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 33,
"end_line": 213,
"start_col": 0,
"start_line": 210
} | (*
Copyright 2014-2015
Simon Forest - Inria and ENS Paris
Catalin Hritcu - Inria
Nikhil Swamy - 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 StlcStrongDbParSubst
open FStar.Constructive
open FStar.Classical
open FStar.FunctionalExtensionality
open FStar.StrongExcludedMiddle
(* Constructive-style progress and preservation proof for STLC with
strong reduction, using deBruijn indices and parallel substitution. *)
type typ =
| TArr : typ -> typ -> typ
| TUnit : typ
type var = nat
type exp =
| EVar : var -> exp
| EApp : exp -> exp -> exp
| ELam : typ -> exp -> exp
| EUnit : exp
(* Parallel substitution operation `subst` *)
(* The termination argument uses a lexicographic ordering composed of:
0) a bit saying whether the expression is a variable or not;
1) an _undecidable_ well-founded order on substitutions that
equates all renamings, equates all non-renamings, and makes
renamings strictly smaller than non-renamings; we write down a
non-constructive function is_renaming mapping substitutions
(infinite objects) to 0 (renaming) or 1 (non-renaming)
2) the structure of the expression e *)
type sub = var -> Tot exp
type renaming (s:sub) = (forall (x:var). EVar? (s x))
val is_renaming : s:sub -> GTot (n:int{ (renaming s ==> n=0) /\
(~(renaming s) ==> n=1)})
let is_renaming s = (if strong_excluded_middle (renaming s) then 0 else 1)
val sub_inc : var -> Tot exp
let sub_inc y = EVar (y+1)
val renaming_sub_inc : unit -> Lemma (renaming (sub_inc))
let renaming_sub_inc _ = ()
let is_var (e:exp) : int = if EVar? e then 0 else 1
val sub_elam: s:sub -> var -> Tot (e:exp{renaming s ==> EVar? e})
(decreases %[1;is_renaming s; 0; EVar 0])
val subst : s:sub -> e:exp -> Pure exp (requires True)
(ensures (fun e' -> (renaming s /\ EVar? e) ==> EVar? e'))
(decreases %[is_var e; is_renaming s; 1; e])
let rec subst s e =
match e with
| EVar x -> s x
| ELam t e1 -> ELam t (subst (sub_elam s) e1)
| EApp e1 e2 -> EApp (subst s e1) (subst s e2)
| EUnit -> EUnit
and sub_elam s y = if y=0 then EVar y
else subst sub_inc (s (y-1))
val sub_beta : exp -> Tot sub
let sub_beta v = fun y -> if y = 0 then v (* substitute *)
else (EVar (y-1)) (* shift -1 *)
(* Small-step operational semantics; strong / full-beta reduction is
non-deterministic, so necessarily as inductive relation *)
type step : exp -> exp -> Type =
| SBeta : t:typ ->
e1:exp ->
e2:exp ->
step (EApp (ELam t e1) e2) (subst (sub_beta e2) e1)
| SApp1 : #e1:exp ->
e2:exp ->
#e1':exp ->
$hst:step e1 e1' ->
step (EApp e1 e2) (EApp e1' e2)
| SApp2 : e1:exp ->
#e2:exp ->
#e2':exp ->
$hst:step e2 e2' ->
step (EApp e1 e2) (EApp e1 e2')
(* Type system; as inductive relation (not strictly necessary for STLC) *)
type env = var -> Tot (option typ)
val empty : env
let empty _ = None
(* we only need extend at 0 *)
val extend : typ -> env -> Tot env
let extend t g y = if y = 0 then Some t
else g (y-1)
noeq type typing : env -> exp -> typ -> Type =
| TyVar : #g:env ->
x:var{Some? (g x)} ->
typing g (EVar x) (Some?.v (g x))
| TyLam : #g :env ->
t :typ ->
#e1:exp ->
#t':typ ->
$hbody:typing (extend t g) e1 t' ->
typing g (ELam t e1) (TArr t t')
| TyApp : #g:env ->
#e1:exp ->
#e2:exp ->
#t11:typ ->
#t12:typ ->
$h1:typing g e1 (TArr t11 t12) ->
$h2:typing g e2 t11 ->
typing g (EApp e1 e2) t12
| TyUnit : #g:env ->
typing g EUnit TUnit
(* Progress *)
val is_value : exp -> Tot bool
let is_value e = ELam? e || EUnit? e
val progress : #e:exp -> #t:typ -> h:typing empty e t ->
Pure (cexists (fun e' -> step e e'))
(requires (~ (is_value e)))
(ensures (fun _ -> True)) (decreases h)
let rec progress #e #t h =
match h with
| TyApp #g #e1 #e2 #t11 #t12 h1 h2 ->
match e1 with
| ELam t e1' -> ExIntro (subst (sub_beta e2) e1') (SBeta t e1' e2)
| _ -> let ExIntro e1' h1' = progress h1 in
ExIntro (EApp e1' e2) (SApp1 e2 h1')
module T = FStar.Tactics.V2
(* Substitution extensional - used by substitution lemma below *)
val subst_extensional: s1:sub -> s2:sub{feq s1 s2} -> e:exp ->
Lemma (requires True)
(ensures (subst s1 e = subst s2 e))
[SMTPat (subst s1 e); SMTPat (subst s2 e)]
let rec subst_extensional s1 s2 e =
match e with
| EVar _ -> ()
| ELam t e1 ->
assert (subst s1 (ELam t e1) == ELam t (subst (sub_elam s1) e1))
by T.norm [zeta; iota; delta_only [`%subst]];
assert (subst s2 (ELam t e1) == ELam t (subst (sub_elam s2) e1))
by T.norm [zeta; iota; delta_only [`%subst]];
subst_extensional (sub_elam s1) (sub_elam s2) e1
| EApp e1 e2 -> subst_extensional s1 s2 e1; subst_extensional s1 s2 e2
| _ -> ()
(* Typing of substitutions (very easy, actually) *)
type subst_typing (s:sub) (g1:env) (g2:env) =
(x:var{Some? (g1 x)} -> Tot(typing g2 (s x) (Some?.v (g1 x))))
(* Substitution preserves typing
Strongest possible statement; suggested by Steven Schäfer *)
val substitution :
#g1:env -> #e:exp -> #t:typ -> s:sub -> #g2:env ->
h1:typing g1 e t ->
hs:subst_typing s g1 g2 ->
Tot (typing g2 (subst s e) t)
(decreases %[is_var e; is_renaming s; e])
let rec substitution #g1 #e #t s #g2 h1 hs =
match h1 with
| TyVar x -> hs x
| TyApp hfun harg -> TyApp (substitution s hfun hs) (substitution s harg hs)
| TyLam tlam hbody ->
let hs'' : subst_typing (sub_inc) g2 (extend tlam g2) =
fun x -> TyVar (x+1) in
let hs' : subst_typing (sub_elam s) (extend tlam g1) (extend tlam g2) =
fun y -> if y = 0 then TyVar y
else let n:var = y - 1 in //Silly limitation of implicits and refinements
substitution sub_inc (hs n) hs'' //NS: needed to instantiate the Some?.v
in TyLam tlam (substitution (sub_elam s) hbody hs')
| TyUnit -> TyUnit
(* Substitution for beta reduction
Now just a special case of substitution lemma *)
val substitution_beta :
#e:exp -> #v:exp -> #t_x:typ -> #t:typ -> #g:env ->
h1:typing g v t_x ->
h2:typing (extend t_x g) e t -> | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Constructive.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "StlcStrongDbParSubst.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.StrongExcludedMiddle",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Constructive",
"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 |
h1: StlcStrongDbParSubst.typing g v t_x ->
h2: StlcStrongDbParSubst.typing (StlcStrongDbParSubst.extend t_x g) e t
-> Prims.Tot
(StlcStrongDbParSubst.typing g
(StlcStrongDbParSubst.subst (StlcStrongDbParSubst.sub_beta v) e)
t) | Prims.Tot | [
"total",
""
] | [] | [
"StlcStrongDbParSubst.exp",
"StlcStrongDbParSubst.typ",
"StlcStrongDbParSubst.env",
"StlcStrongDbParSubst.typing",
"StlcStrongDbParSubst.extend",
"StlcStrongDbParSubst.substitution",
"StlcStrongDbParSubst.sub_beta",
"StlcStrongDbParSubst.subst_typing",
"StlcStrongDbParSubst.var",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"StlcStrongDbParSubst.TyVar",
"Prims.op_Subtraction",
"FStar.Pervasives.Native.__proj__Some__item__v",
"StlcStrongDbParSubst.subst"
] | [
"recursion"
] | false | false | false | false | false | let rec substitution_beta #e #v #t_x #t #g h1 h2 =
| let hs:subst_typing (sub_beta v) (extend t_x g) g = fun y -> if y = 0 then h1 else TyVar (y - 1) in
substitution (sub_beta v) h2 hs | false |
StlcStrongDbParSubst.fst | StlcStrongDbParSubst.subst | val subst : s:sub -> e:exp -> Pure exp (requires True)
(ensures (fun e' -> (renaming s /\ EVar? e) ==> EVar? e'))
(decreases %[is_var e; is_renaming s; 1; e]) | val subst : s:sub -> e:exp -> Pure exp (requires True)
(ensures (fun e' -> (renaming s /\ EVar? e) ==> EVar? e'))
(decreases %[is_var e; is_renaming s; 1; e]) | let rec subst s e =
match e with
| EVar x -> s x
| ELam t e1 -> ELam t (subst (sub_elam s) e1)
| EApp e1 e2 -> EApp (subst s e1) (subst s e2)
| EUnit -> EUnit
and sub_elam s y = if y=0 then EVar y
else subst sub_inc (s (y-1)) | {
"file_name": "examples/metatheory/StlcStrongDbParSubst.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 47,
"end_line": 83,
"start_col": 0,
"start_line": 75
} | (*
Copyright 2014-2015
Simon Forest - Inria and ENS Paris
Catalin Hritcu - Inria
Nikhil Swamy - 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 StlcStrongDbParSubst
open FStar.Constructive
open FStar.Classical
open FStar.FunctionalExtensionality
open FStar.StrongExcludedMiddle
(* Constructive-style progress and preservation proof for STLC with
strong reduction, using deBruijn indices and parallel substitution. *)
type typ =
| TArr : typ -> typ -> typ
| TUnit : typ
type var = nat
type exp =
| EVar : var -> exp
| EApp : exp -> exp -> exp
| ELam : typ -> exp -> exp
| EUnit : exp
(* Parallel substitution operation `subst` *)
(* The termination argument uses a lexicographic ordering composed of:
0) a bit saying whether the expression is a variable or not;
1) an _undecidable_ well-founded order on substitutions that
equates all renamings, equates all non-renamings, and makes
renamings strictly smaller than non-renamings; we write down a
non-constructive function is_renaming mapping substitutions
(infinite objects) to 0 (renaming) or 1 (non-renaming)
2) the structure of the expression e *)
type sub = var -> Tot exp
type renaming (s:sub) = (forall (x:var). EVar? (s x))
val is_renaming : s:sub -> GTot (n:int{ (renaming s ==> n=0) /\
(~(renaming s) ==> n=1)})
let is_renaming s = (if strong_excluded_middle (renaming s) then 0 else 1)
val sub_inc : var -> Tot exp
let sub_inc y = EVar (y+1)
val renaming_sub_inc : unit -> Lemma (renaming (sub_inc))
let renaming_sub_inc _ = ()
let is_var (e:exp) : int = if EVar? e then 0 else 1
val sub_elam: s:sub -> var -> Tot (e:exp{renaming s ==> EVar? e})
(decreases %[1;is_renaming s; 0; EVar 0])
val subst : s:sub -> e:exp -> Pure exp (requires True)
(ensures (fun e' -> (renaming s /\ EVar? e) ==> EVar? e')) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Constructive.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "StlcStrongDbParSubst.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.StrongExcludedMiddle",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Constructive",
"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: StlcStrongDbParSubst.sub -> e: StlcStrongDbParSubst.exp -> Prims.Pure StlcStrongDbParSubst.exp | Prims.Pure | [
""
] | [
"subst",
"sub_elam"
] | [
"StlcStrongDbParSubst.sub",
"StlcStrongDbParSubst.exp",
"StlcStrongDbParSubst.var",
"StlcStrongDbParSubst.typ",
"StlcStrongDbParSubst.ELam",
"StlcStrongDbParSubst.subst",
"StlcStrongDbParSubst.sub_elam",
"StlcStrongDbParSubst.EApp",
"StlcStrongDbParSubst.EUnit"
] | [
"mutual recursion"
] | false | false | false | false | false | let rec subst s e =
| match e with
| EVar x -> s x
| ELam t e1 -> ELam t (subst (sub_elam s) e1)
| EApp e1 e2 -> EApp (subst s e1) (subst s e2)
| EUnit -> EUnit | false |
Vale.Curve25519.X64.FastUtil.fsti | Vale.Curve25519.X64.FastUtil.va_ens_Cswap2 | val va_ens_Cswap2
(va_b0: va_code)
(va_s0: va_state)
(bit_in: nat64)
(p0_b p1_b: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop | val va_ens_Cswap2
(va_b0: va_code)
(va_s0: va_state)
(bit_in: nat64)
(p0_b p1_b: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop | let va_ens_Cswap2 (va_b0:va_code) (va_s0:va_state) (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Cswap2 va_b0 va_s0 bit_in p0_b p1_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0
(va_get_mem va_s0) in let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
1 (va_get_mem va_s0) in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 2 (va_get_mem va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_s0) in let
(old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in
let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0)
in let (old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem
va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0
(va_get_mem va_s0) in let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
1 (va_get_mem va_s0) in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 2 (va_get_mem va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_s0) in let
(old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in
let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0)
in let (old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem
va_s0) in Vale.X64.Decls.modifies_buffer_2 p0_b p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\
(let p0_0 = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_sM) in let p0_1 =
Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let p0_2 =
Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == (if (va_get_reg64 rRdi va_s0
= 1) then old_p1_0 else old_p0_0) /\ p0_1 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_1
else old_p0_1) /\ p0_2 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_2 else old_p0_2) /\
p0_3 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_3 else old_p0_3) /\ p0_4 == (if
(va_get_reg64 rRdi va_s0 = 1) then old_p1_4 else old_p0_4) /\ p0_5 == (if (va_get_reg64 rRdi
va_s0 = 1) then old_p1_5 else old_p0_5) /\ p0_6 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p1_6 else old_p0_6) /\ p0_7 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_7 else
old_p0_7) /\ p1_0 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_0 else old_p1_0) /\ p1_1 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_1 else old_p1_1) /\ p1_2 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_2 else old_p1_2) /\ p1_3 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p0_3 else old_p1_3) /\ p1_4 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_4 else
old_p1_4) /\ p1_5 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_5 else old_p1_5) /\ p1_6 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_6 else old_p1_6) /\ p1_7 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_7 else old_p1_7))) /\ va_state_eq va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdi va_sM (va_update_ok
va_sM (va_update_mem va_sM va_s0)))))))))) | {
"file_name": "obj/Vale.Curve25519.X64.FastUtil.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 46,
"end_line": 386,
"start_col": 0,
"start_line": 333
} | module Vale.Curve25519.X64.FastUtil
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Fast_add1
val va_code_Fast_add1 : va_dummy:unit -> Tot va_code
val va_codegen_success_Fast_add1 : va_dummy:unit -> Tot va_pbool
let va_req_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
: prop =
(va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0))
let va_ens_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1 va_b0 va_s0 dst_b inA_b inB /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fast_add1 : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
adx_enabled /\ bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0)
(va_get_mem va_s0) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rdx:nat64) (va_x_r8:nat64)
(va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64) (va_x_heap0:vale_heap)
(va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11
va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8
(va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) ==> va_k va_sM (())))
val va_wpProof_Fast_add1 : dst_b:buffer64 -> inA_b:buffer64 -> inB:nat64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_add1 dst_b inA_b inB va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_add1 ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) : (va_quickCode unit
(va_code_Fast_add1 ())) =
(va_QProc (va_code_Fast_add1 ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx;
va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fast_add1 dst_b inA_b inB) (va_wpProof_Fast_add1 dst_b
inA_b inB))
//--
//-- Fast_add1_stdcall
val va_code_Fast_add1_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fast_add1_stdcall : win:bool -> Tot va_pbool
let va_req_Fast_add1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) : prop =
(va_require_total va_b0 (va_code_Fast_add1_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret))
let va_ens_Fast_add1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1_stdcall va_b0 va_s0 win dst_b inA_b inB_in /\ va_ensure_total va_b0 va_s0 va_sM
va_fM /\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fast_add1_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_in:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_add1_stdcall win) va_s0 /\ va_get_ok va_s0 /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let a0 = Vale.X64.Decls.buffer64_read
inA_b 0 (va_get_mem va_s0) in let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0)
in let a2 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fast_add1_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_in:nat64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in =
va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rbx:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64) (va_x_rbp:nat64)
(va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64)
(va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let a0 =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) ==> va_k va_sM (())))
val va_wpProof_Fast_add1_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_in:nat64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_add1_stdcall win dst_b inA_b inB_in va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_add1_stdcall win)
([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags;
va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10;
va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi;
va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax;
va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_add1_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_in:nat64) :
(va_quickCode unit (va_code_Fast_add1_stdcall win)) =
(va_QProc (va_code_Fast_add1_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fast_add1_stdcall win dst_b inA_b
inB_in) (va_wpProof_Fast_add1_stdcall win dst_b inA_b inB_in))
//--
//-- Cswap2
val va_code_Cswap2 : va_dummy:unit -> Tot va_code
val va_codegen_success_Cswap2 : va_dummy:unit -> Tot va_pbool
let va_req_Cswap2 (va_b0:va_code) (va_s0:va_state) (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64) :
prop =
(va_require_total va_b0 (va_code_Cswap2 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in
let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0)
in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem
va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3
(va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in let
(old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in
let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0)
in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem
va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3
(va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ bit_in == va_get_reg64 rRdi va_s0 /\
va_get_reg64 rRdi va_s0 <= 1 /\ (Vale.X64.Decls.buffers_disjoint p1_b p0_b \/ p1_b == p0_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRsi va_s0) p0_b 8
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastUtil.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
bit_in: Vale.X64.Memory.nat64 ->
p0_b: Vale.X64.Memory.buffer64 ->
p1_b: Vale.X64.Memory.buffer64 ->
va_sM: Vale.X64.Decls.va_state ->
va_fM: Vale.X64.Decls.va_fuel
-> Prims.prop | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Memory.nat64",
"Vale.X64.Memory.buffer64",
"Vale.X64.Decls.va_fuel",
"Prims.l_and",
"Vale.Curve25519.X64.FastUtil.va_req_Cswap2",
"Vale.X64.Decls.va_ensure_total",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.Decls.modifies_buffer_2",
"Vale.X64.Decls.va_get_mem",
"Prims.eq2",
"Vale.Def.Words_s.nat64",
"Prims.op_Equality",
"Prims.int",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRdi",
"Prims.bool",
"Vale.X64.Decls.buffer64_read",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_mem_layout",
"Vale.X64.Decls.va_update_mem_heaplet",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_reg64",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_mem",
"Prims.prop"
] | [] | false | false | false | true | true | let va_ens_Cswap2
(va_b0: va_code)
(va_s0: va_state)
(bit_in: nat64)
(p0_b p1_b: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop =
| (va_req_Cswap2 va_b0 va_s0 bit_in p0_b p1_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\
(let old_p0_0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in
let old_p0_1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0) in
let old_p0_2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_s0) in
let old_p0_3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0) in
let old_p0_4:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_s0) in
let old_p0_5:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in
let old_p0_6:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in
let old_p0_7:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in
let old_p1_0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in
let old_p1_1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0) in
let old_p1_2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_s0) in
let old_p1_3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0) in
let old_p1_4:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_s0) in
let old_p1_5:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in
let old_p1_6:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in
let old_p1_7:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in
Vale.X64.Decls.modifies_buffer_2 p0_b p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\
(let p0_0 = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_sM) in
let p0_1 = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in
let p0_2 = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in
let p0_3 = Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in
let p0_4 = Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in
let p0_5 = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in
let p0_6 = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in
let p0_7 = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in
let p1_0 = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in
let p1_1 = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in
let p1_2 = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in
let p1_3 = Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in
let p1_4 = Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in
let p1_5 = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in
let p1_6 = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in
let p1_7 = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in
p0_0 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_0 else old_p0_0) /\
p0_1 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_1 else old_p0_1) /\
p0_2 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_2 else old_p0_2) /\
p0_3 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_3 else old_p0_3) /\
p0_4 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_4 else old_p0_4) /\
p0_5 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_5 else old_p0_5) /\
p0_6 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_6 else old_p0_6) /\
p0_7 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_7 else old_p0_7) /\
p1_0 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_0 else old_p1_0) /\
p1_1 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_1 else old_p1_1) /\
p1_2 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_2 else old_p1_2) /\
p1_3 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_3 else old_p1_3) /\
p1_4 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_4 else old_p1_4) /\
p1_5 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_5 else old_p1_5) /\
p1_6 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_6 else old_p1_6) /\
p1_7 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_7 else old_p1_7))) /\
va_state_eq va_sM
(va_update_mem_layout va_sM
(va_update_mem_heaplet 0
va_sM
(va_update_flags va_sM
(va_update_reg64 rR10
va_sM
(va_update_reg64 rR9
va_sM
(va_update_reg64 rR8
va_sM
(va_update_reg64 rRdi
va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))) | false |
Steel.MonotonicHigherReference.fst | Steel.MonotonicHigherReference.intro_pure | val intro_pure (#a #p #f: _) (r: ref a p) (v: a) (h: history a p {history_val h v f})
: SteelT unit (PR.pts_to r h) (fun _ -> pts_to_body r f v h) | val intro_pure (#a #p #f: _) (r: ref a p) (v: a) (h: history a p {history_val h v f})
: SteelT unit (PR.pts_to r h) (fun _ -> pts_to_body r f v h) | let intro_pure #a #p #f
(r:ref a p)
(v:a)
(h:history a p { history_val h v f })
: SteelT unit
(PR.pts_to r h)
(fun _ -> pts_to_body r f v h)
= rewrite_slprop (PR.pts_to r h) (pts_to_body _ _ _ _) (fun m ->
emp_unit (M.pts_to r h);
pure_star_interp (M.pts_to r h) (history_val h v f) m) | {
"file_name": "lib/steel/Steel.MonotonicHigherReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 60,
"end_line": 57,
"start_col": 0,
"start_line": 48
} | (*
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.MonotonicHigherReference
open FStar.Ghost
open FStar.PCM
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open Steel.PCMReference
open Steel.FractionalPermission
open Steel.Preorder
module Preorder = FStar.Preorder
module Q = Steel.Preorder
module M = Steel.Memory
module PR = Steel.PCMReference
open FStar.Real
#set-options "--ide_id_info_off"
let ref a p = M.ref (history a p) pcm_history
[@@__reduce__]
let pts_to_body #a #p (r:ref a p) (f:perm) (v:Ghost.erased a) (h:history a p) =
PR.pts_to r h `star`
pure (history_val h v f)
let pts_to' (#a:Type) (#p:Preorder.preorder a) (r:ref a p) (f:perm) (v:Ghost.erased a) =
h_exists (pts_to_body r f v)
let pts_to_sl r f v = hp_of (pts_to' r f v) | {
"checked_file": "/",
"dependencies": [
"Steel.Preorder.fst.checked",
"Steel.PCMReference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.MonotonicHigherReference.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "PR"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "Steel.Preorder",
"short_module": "Q"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMReference",
"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.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"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": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"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 |
r: Steel.MonotonicHigherReference.ref a p ->
v: a ->
h: Steel.Preorder.history a p {Steel.Preorder.history_val h (FStar.Ghost.hide v) f}
-> Steel.Effect.SteelT Prims.unit | Steel.Effect.SteelT | [] | [] | [
"FStar.Preorder.preorder",
"Steel.FractionalPermission.perm",
"Steel.MonotonicHigherReference.ref",
"Steel.Preorder.history",
"Steel.Preorder.history_val",
"FStar.Ghost.hide",
"Steel.Effect.Atomic.rewrite_slprop",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.PCMReference.pts_to",
"Steel.Preorder.pcm_history",
"Steel.MonotonicHigherReference.pts_to_body",
"Steel.Memory.mem",
"Steel.Memory.pure_star_interp",
"Steel.Memory.pts_to",
"Prims.unit",
"Steel.Memory.emp_unit",
"Steel.Effect.Common.vprop"
] | [] | false | true | false | false | false | let intro_pure #a #p #f (r: ref a p) (v: a) (h: history a p {history_val h v f})
: SteelT unit (PR.pts_to r h) (fun _ -> pts_to_body r f v h) =
| rewrite_slprop (PR.pts_to r h)
(pts_to_body _ _ _ _)
(fun m ->
emp_unit (M.pts_to r h);
pure_star_interp (M.pts_to r h) (history_val h v f) m) | false |
StlcStrongDbParSubst.fst | StlcStrongDbParSubst.subst_extensional | val subst_extensional: s1:sub -> s2:sub{feq s1 s2} -> e:exp ->
Lemma (requires True)
(ensures (subst s1 e = subst s2 e))
[SMTPat (subst s1 e); SMTPat (subst s2 e)] | val subst_extensional: s1:sub -> s2:sub{feq s1 s2} -> e:exp ->
Lemma (requires True)
(ensures (subst s1 e = subst s2 e))
[SMTPat (subst s1 e); SMTPat (subst s2 e)] | let rec subst_extensional s1 s2 e =
match e with
| EVar _ -> ()
| ELam t e1 ->
assert (subst s1 (ELam t e1) == ELam t (subst (sub_elam s1) e1))
by T.norm [zeta; iota; delta_only [`%subst]];
assert (subst s2 (ELam t e1) == ELam t (subst (sub_elam s2) e1))
by T.norm [zeta; iota; delta_only [`%subst]];
subst_extensional (sub_elam s1) (sub_elam s2) e1
| EApp e1 e2 -> subst_extensional s1 s2 e1; subst_extensional s1 s2 e2
| _ -> () | {
"file_name": "examples/metatheory/StlcStrongDbParSubst.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 11,
"end_line": 175,
"start_col": 0,
"start_line": 165
} | (*
Copyright 2014-2015
Simon Forest - Inria and ENS Paris
Catalin Hritcu - Inria
Nikhil Swamy - 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 StlcStrongDbParSubst
open FStar.Constructive
open FStar.Classical
open FStar.FunctionalExtensionality
open FStar.StrongExcludedMiddle
(* Constructive-style progress and preservation proof for STLC with
strong reduction, using deBruijn indices and parallel substitution. *)
type typ =
| TArr : typ -> typ -> typ
| TUnit : typ
type var = nat
type exp =
| EVar : var -> exp
| EApp : exp -> exp -> exp
| ELam : typ -> exp -> exp
| EUnit : exp
(* Parallel substitution operation `subst` *)
(* The termination argument uses a lexicographic ordering composed of:
0) a bit saying whether the expression is a variable or not;
1) an _undecidable_ well-founded order on substitutions that
equates all renamings, equates all non-renamings, and makes
renamings strictly smaller than non-renamings; we write down a
non-constructive function is_renaming mapping substitutions
(infinite objects) to 0 (renaming) or 1 (non-renaming)
2) the structure of the expression e *)
type sub = var -> Tot exp
type renaming (s:sub) = (forall (x:var). EVar? (s x))
val is_renaming : s:sub -> GTot (n:int{ (renaming s ==> n=0) /\
(~(renaming s) ==> n=1)})
let is_renaming s = (if strong_excluded_middle (renaming s) then 0 else 1)
val sub_inc : var -> Tot exp
let sub_inc y = EVar (y+1)
val renaming_sub_inc : unit -> Lemma (renaming (sub_inc))
let renaming_sub_inc _ = ()
let is_var (e:exp) : int = if EVar? e then 0 else 1
val sub_elam: s:sub -> var -> Tot (e:exp{renaming s ==> EVar? e})
(decreases %[1;is_renaming s; 0; EVar 0])
val subst : s:sub -> e:exp -> Pure exp (requires True)
(ensures (fun e' -> (renaming s /\ EVar? e) ==> EVar? e'))
(decreases %[is_var e; is_renaming s; 1; e])
let rec subst s e =
match e with
| EVar x -> s x
| ELam t e1 -> ELam t (subst (sub_elam s) e1)
| EApp e1 e2 -> EApp (subst s e1) (subst s e2)
| EUnit -> EUnit
and sub_elam s y = if y=0 then EVar y
else subst sub_inc (s (y-1))
val sub_beta : exp -> Tot sub
let sub_beta v = fun y -> if y = 0 then v (* substitute *)
else (EVar (y-1)) (* shift -1 *)
(* Small-step operational semantics; strong / full-beta reduction is
non-deterministic, so necessarily as inductive relation *)
type step : exp -> exp -> Type =
| SBeta : t:typ ->
e1:exp ->
e2:exp ->
step (EApp (ELam t e1) e2) (subst (sub_beta e2) e1)
| SApp1 : #e1:exp ->
e2:exp ->
#e1':exp ->
$hst:step e1 e1' ->
step (EApp e1 e2) (EApp e1' e2)
| SApp2 : e1:exp ->
#e2:exp ->
#e2':exp ->
$hst:step e2 e2' ->
step (EApp e1 e2) (EApp e1 e2')
(* Type system; as inductive relation (not strictly necessary for STLC) *)
type env = var -> Tot (option typ)
val empty : env
let empty _ = None
(* we only need extend at 0 *)
val extend : typ -> env -> Tot env
let extend t g y = if y = 0 then Some t
else g (y-1)
noeq type typing : env -> exp -> typ -> Type =
| TyVar : #g:env ->
x:var{Some? (g x)} ->
typing g (EVar x) (Some?.v (g x))
| TyLam : #g :env ->
t :typ ->
#e1:exp ->
#t':typ ->
$hbody:typing (extend t g) e1 t' ->
typing g (ELam t e1) (TArr t t')
| TyApp : #g:env ->
#e1:exp ->
#e2:exp ->
#t11:typ ->
#t12:typ ->
$h1:typing g e1 (TArr t11 t12) ->
$h2:typing g e2 t11 ->
typing g (EApp e1 e2) t12
| TyUnit : #g:env ->
typing g EUnit TUnit
(* Progress *)
val is_value : exp -> Tot bool
let is_value e = ELam? e || EUnit? e
val progress : #e:exp -> #t:typ -> h:typing empty e t ->
Pure (cexists (fun e' -> step e e'))
(requires (~ (is_value e)))
(ensures (fun _ -> True)) (decreases h)
let rec progress #e #t h =
match h with
| TyApp #g #e1 #e2 #t11 #t12 h1 h2 ->
match e1 with
| ELam t e1' -> ExIntro (subst (sub_beta e2) e1') (SBeta t e1' e2)
| _ -> let ExIntro e1' h1' = progress h1 in
ExIntro (EApp e1' e2) (SApp1 e2 h1')
module T = FStar.Tactics.V2
(* Substitution extensional - used by substitution lemma below *)
val subst_extensional: s1:sub -> s2:sub{feq s1 s2} -> e:exp ->
Lemma (requires True)
(ensures (subst s1 e = subst s2 e)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Constructive.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "StlcStrongDbParSubst.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.StrongExcludedMiddle",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Constructive",
"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 |
s1: StlcStrongDbParSubst.sub ->
s2: StlcStrongDbParSubst.sub{FStar.FunctionalExtensionality.feq s1 s2} ->
e: StlcStrongDbParSubst.exp
-> FStar.Pervasives.Lemma
(ensures StlcStrongDbParSubst.subst s1 e = StlcStrongDbParSubst.subst s2 e)
[SMTPat (StlcStrongDbParSubst.subst s1 e); SMTPat (StlcStrongDbParSubst.subst s2 e)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"StlcStrongDbParSubst.sub",
"FStar.FunctionalExtensionality.feq",
"StlcStrongDbParSubst.var",
"StlcStrongDbParSubst.exp",
"StlcStrongDbParSubst.typ",
"StlcStrongDbParSubst.subst_extensional",
"StlcStrongDbParSubst.sub_elam",
"Prims.unit",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"StlcStrongDbParSubst.subst",
"StlcStrongDbParSubst.ELam",
"FStar.Stubs.Tactics.V2.Builtins.norm",
"Prims.Cons",
"FStar.Pervasives.norm_step",
"FStar.Pervasives.zeta",
"FStar.Pervasives.iota",
"FStar.Pervasives.delta_only",
"Prims.string",
"Prims.Nil"
] | [
"recursion"
] | false | false | true | false | false | let rec subst_extensional s1 s2 e =
| match e with
| EVar _ -> ()
| ELam t e1 ->
FStar.Tactics.Effect.assert_by_tactic (subst s1 (ELam t e1) == ELam t (subst (sub_elam s1) e1))
(fun _ ->
();
T.norm [zeta; iota; delta_only [`%subst]]);
FStar.Tactics.Effect.assert_by_tactic (subst s2 (ELam t e1) == ELam t (subst (sub_elam s2) e1))
(fun _ ->
();
T.norm [zeta; iota; delta_only [`%subst]]);
subst_extensional (sub_elam s1) (sub_elam s2) e1
| EApp e1 e2 ->
subst_extensional s1 s2 e1;
subst_extensional s1 s2 e2
| _ -> () | false |
StlcStrongDbParSubst.fst | StlcStrongDbParSubst.substitution | val substitution :
#g1:env -> #e:exp -> #t:typ -> s:sub -> #g2:env ->
h1:typing g1 e t ->
hs:subst_typing s g1 g2 ->
Tot (typing g2 (subst s e) t)
(decreases %[is_var e; is_renaming s; e]) | val substitution :
#g1:env -> #e:exp -> #t:typ -> s:sub -> #g2:env ->
h1:typing g1 e t ->
hs:subst_typing s g1 g2 ->
Tot (typing g2 (subst s e) t)
(decreases %[is_var e; is_renaming s; e]) | let rec substitution #g1 #e #t s #g2 h1 hs =
match h1 with
| TyVar x -> hs x
| TyApp hfun harg -> TyApp (substitution s hfun hs) (substitution s harg hs)
| TyLam tlam hbody ->
let hs'' : subst_typing (sub_inc) g2 (extend tlam g2) =
fun x -> TyVar (x+1) in
let hs' : subst_typing (sub_elam s) (extend tlam g1) (extend tlam g2) =
fun y -> if y = 0 then TyVar y
else let n:var = y - 1 in //Silly limitation of implicits and refinements
substitution sub_inc (hs n) hs'' //NS: needed to instantiate the Some?.v
in TyLam tlam (substitution (sub_elam s) hbody hs')
| TyUnit -> TyUnit | {
"file_name": "examples/metatheory/StlcStrongDbParSubst.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 20,
"end_line": 201,
"start_col": 0,
"start_line": 189
} | (*
Copyright 2014-2015
Simon Forest - Inria and ENS Paris
Catalin Hritcu - Inria
Nikhil Swamy - 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 StlcStrongDbParSubst
open FStar.Constructive
open FStar.Classical
open FStar.FunctionalExtensionality
open FStar.StrongExcludedMiddle
(* Constructive-style progress and preservation proof for STLC with
strong reduction, using deBruijn indices and parallel substitution. *)
type typ =
| TArr : typ -> typ -> typ
| TUnit : typ
type var = nat
type exp =
| EVar : var -> exp
| EApp : exp -> exp -> exp
| ELam : typ -> exp -> exp
| EUnit : exp
(* Parallel substitution operation `subst` *)
(* The termination argument uses a lexicographic ordering composed of:
0) a bit saying whether the expression is a variable or not;
1) an _undecidable_ well-founded order on substitutions that
equates all renamings, equates all non-renamings, and makes
renamings strictly smaller than non-renamings; we write down a
non-constructive function is_renaming mapping substitutions
(infinite objects) to 0 (renaming) or 1 (non-renaming)
2) the structure of the expression e *)
type sub = var -> Tot exp
type renaming (s:sub) = (forall (x:var). EVar? (s x))
val is_renaming : s:sub -> GTot (n:int{ (renaming s ==> n=0) /\
(~(renaming s) ==> n=1)})
let is_renaming s = (if strong_excluded_middle (renaming s) then 0 else 1)
val sub_inc : var -> Tot exp
let sub_inc y = EVar (y+1)
val renaming_sub_inc : unit -> Lemma (renaming (sub_inc))
let renaming_sub_inc _ = ()
let is_var (e:exp) : int = if EVar? e then 0 else 1
val sub_elam: s:sub -> var -> Tot (e:exp{renaming s ==> EVar? e})
(decreases %[1;is_renaming s; 0; EVar 0])
val subst : s:sub -> e:exp -> Pure exp (requires True)
(ensures (fun e' -> (renaming s /\ EVar? e) ==> EVar? e'))
(decreases %[is_var e; is_renaming s; 1; e])
let rec subst s e =
match e with
| EVar x -> s x
| ELam t e1 -> ELam t (subst (sub_elam s) e1)
| EApp e1 e2 -> EApp (subst s e1) (subst s e2)
| EUnit -> EUnit
and sub_elam s y = if y=0 then EVar y
else subst sub_inc (s (y-1))
val sub_beta : exp -> Tot sub
let sub_beta v = fun y -> if y = 0 then v (* substitute *)
else (EVar (y-1)) (* shift -1 *)
(* Small-step operational semantics; strong / full-beta reduction is
non-deterministic, so necessarily as inductive relation *)
type step : exp -> exp -> Type =
| SBeta : t:typ ->
e1:exp ->
e2:exp ->
step (EApp (ELam t e1) e2) (subst (sub_beta e2) e1)
| SApp1 : #e1:exp ->
e2:exp ->
#e1':exp ->
$hst:step e1 e1' ->
step (EApp e1 e2) (EApp e1' e2)
| SApp2 : e1:exp ->
#e2:exp ->
#e2':exp ->
$hst:step e2 e2' ->
step (EApp e1 e2) (EApp e1 e2')
(* Type system; as inductive relation (not strictly necessary for STLC) *)
type env = var -> Tot (option typ)
val empty : env
let empty _ = None
(* we only need extend at 0 *)
val extend : typ -> env -> Tot env
let extend t g y = if y = 0 then Some t
else g (y-1)
noeq type typing : env -> exp -> typ -> Type =
| TyVar : #g:env ->
x:var{Some? (g x)} ->
typing g (EVar x) (Some?.v (g x))
| TyLam : #g :env ->
t :typ ->
#e1:exp ->
#t':typ ->
$hbody:typing (extend t g) e1 t' ->
typing g (ELam t e1) (TArr t t')
| TyApp : #g:env ->
#e1:exp ->
#e2:exp ->
#t11:typ ->
#t12:typ ->
$h1:typing g e1 (TArr t11 t12) ->
$h2:typing g e2 t11 ->
typing g (EApp e1 e2) t12
| TyUnit : #g:env ->
typing g EUnit TUnit
(* Progress *)
val is_value : exp -> Tot bool
let is_value e = ELam? e || EUnit? e
val progress : #e:exp -> #t:typ -> h:typing empty e t ->
Pure (cexists (fun e' -> step e e'))
(requires (~ (is_value e)))
(ensures (fun _ -> True)) (decreases h)
let rec progress #e #t h =
match h with
| TyApp #g #e1 #e2 #t11 #t12 h1 h2 ->
match e1 with
| ELam t e1' -> ExIntro (subst (sub_beta e2) e1') (SBeta t e1' e2)
| _ -> let ExIntro e1' h1' = progress h1 in
ExIntro (EApp e1' e2) (SApp1 e2 h1')
module T = FStar.Tactics.V2
(* Substitution extensional - used by substitution lemma below *)
val subst_extensional: s1:sub -> s2:sub{feq s1 s2} -> e:exp ->
Lemma (requires True)
(ensures (subst s1 e = subst s2 e))
[SMTPat (subst s1 e); SMTPat (subst s2 e)]
let rec subst_extensional s1 s2 e =
match e with
| EVar _ -> ()
| ELam t e1 ->
assert (subst s1 (ELam t e1) == ELam t (subst (sub_elam s1) e1))
by T.norm [zeta; iota; delta_only [`%subst]];
assert (subst s2 (ELam t e1) == ELam t (subst (sub_elam s2) e1))
by T.norm [zeta; iota; delta_only [`%subst]];
subst_extensional (sub_elam s1) (sub_elam s2) e1
| EApp e1 e2 -> subst_extensional s1 s2 e1; subst_extensional s1 s2 e2
| _ -> ()
(* Typing of substitutions (very easy, actually) *)
type subst_typing (s:sub) (g1:env) (g2:env) =
(x:var{Some? (g1 x)} -> Tot(typing g2 (s x) (Some?.v (g1 x))))
(* Substitution preserves typing
Strongest possible statement; suggested by Steven Schäfer *)
val substitution :
#g1:env -> #e:exp -> #t:typ -> s:sub -> #g2:env ->
h1:typing g1 e t ->
hs:subst_typing s g1 g2 ->
Tot (typing g2 (subst s e) t) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Constructive.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "StlcStrongDbParSubst.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.StrongExcludedMiddle",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Constructive",
"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: StlcStrongDbParSubst.sub ->
h1: StlcStrongDbParSubst.typing g1 e t ->
hs: StlcStrongDbParSubst.subst_typing s g1 g2
-> Prims.Tot (StlcStrongDbParSubst.typing g2 (StlcStrongDbParSubst.subst s e) t) | Prims.Tot | [
"total",
""
] | [] | [
"StlcStrongDbParSubst.env",
"StlcStrongDbParSubst.exp",
"StlcStrongDbParSubst.typ",
"StlcStrongDbParSubst.sub",
"StlcStrongDbParSubst.typing",
"StlcStrongDbParSubst.subst_typing",
"StlcStrongDbParSubst.var",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"StlcStrongDbParSubst.TArr",
"StlcStrongDbParSubst.TyApp",
"StlcStrongDbParSubst.subst",
"StlcStrongDbParSubst.substitution",
"StlcStrongDbParSubst.extend",
"StlcStrongDbParSubst.TyLam",
"StlcStrongDbParSubst.sub_elam",
"Prims.op_Equality",
"Prims.int",
"StlcStrongDbParSubst.TyVar",
"Prims.bool",
"FStar.Pervasives.Native.__proj__Some__item__v",
"StlcStrongDbParSubst.sub_inc",
"Prims.op_Subtraction",
"Prims.op_Addition",
"StlcStrongDbParSubst.TyUnit"
] | [
"recursion"
] | false | false | false | false | false | let rec substitution #g1 #e #t s #g2 h1 hs =
| match h1 with
| TyVar x -> hs x
| TyApp hfun harg -> TyApp (substitution s hfun hs) (substitution s harg hs)
| TyLam tlam hbody ->
let hs'':subst_typing (sub_inc) g2 (extend tlam g2) = fun x -> TyVar (x + 1) in
let hs':subst_typing (sub_elam s) (extend tlam g1) (extend tlam g2) =
fun y ->
if y = 0
then TyVar y
else
let n:var = y - 1 in
substitution sub_inc (hs n) hs''
in
TyLam tlam (substitution (sub_elam s) hbody hs')
| TyUnit -> TyUnit | false |
Vale.Curve25519.X64.FastUtil.fsti | Vale.Curve25519.X64.FastUtil.va_ens_Fast_add1_stdcall | val va_ens_Fast_add1_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst_b inA_b: buffer64)
(inB_in: nat64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop | val va_ens_Fast_add1_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst_b inA_b: buffer64)
(inB_in: nat64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop | let va_ens_Fast_add1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1_stdcall va_b0 va_s0 win dst_b inA_b inB_in /\ va_ensure_total va_b0 va_s0 va_sM
va_fM /\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))))))) | {
"file_name": "obj/Vale.Curve25519.X64.FastUtil.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 73,
"end_line": 185,
"start_col": 0,
"start_line": 152
} | module Vale.Curve25519.X64.FastUtil
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Fast_add1
val va_code_Fast_add1 : va_dummy:unit -> Tot va_code
val va_codegen_success_Fast_add1 : va_dummy:unit -> Tot va_pbool
let va_req_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
: prop =
(va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0))
let va_ens_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1 va_b0 va_s0 dst_b inA_b inB /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fast_add1 : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
adx_enabled /\ bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0)
(va_get_mem va_s0) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rdx:nat64) (va_x_r8:nat64)
(va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64) (va_x_heap0:vale_heap)
(va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11
va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8
(va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) ==> va_k va_sM (())))
val va_wpProof_Fast_add1 : dst_b:buffer64 -> inA_b:buffer64 -> inB:nat64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_add1 dst_b inA_b inB va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_add1 ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) : (va_quickCode unit
(va_code_Fast_add1 ())) =
(va_QProc (va_code_Fast_add1 ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx;
va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fast_add1 dst_b inA_b inB) (va_wpProof_Fast_add1 dst_b
inA_b inB))
//--
//-- Fast_add1_stdcall
val va_code_Fast_add1_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fast_add1_stdcall : win:bool -> Tot va_pbool
let va_req_Fast_add1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) : prop =
(va_require_total va_b0 (va_code_Fast_add1_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastUtil.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
win: Prims.bool ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB_in: Vale.X64.Memory.nat64 ->
va_sM: Vale.X64.Decls.va_state ->
va_fM: Vale.X64.Decls.va_fuel
-> Prims.prop | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Vale.X64.Memory.nat64",
"Vale.X64.Decls.va_fuel",
"Prims.l_and",
"Vale.Curve25519.X64.FastUtil.va_req_Fast_add1_stdcall",
"Vale.X64.Decls.va_ensure_total",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.eq2",
"Prims.int",
"Prims.op_Addition",
"Vale.X64.Decls.modifies_buffer",
"Vale.X64.Decls.va_get_mem",
"Prims.l_imp",
"Vale.Def.Types_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rRbp",
"Vale.X64.Machine_s.rRdi",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rR14",
"Vale.X64.Machine_s.rR15",
"Prims.l_not",
"Prims.nat",
"Vale.Curve25519.Fast_defs.pow2_five",
"Vale.X64.Machine_s.rRax",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.buffer64_read",
"Vale.X64.Decls.va_int_range",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_stackTaint",
"Vale.X64.Decls.va_update_stack",
"Vale.X64.Decls.va_update_mem_layout",
"Vale.X64.Decls.va_update_mem_heaplet",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_reg64",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_mem",
"Prims.prop"
] | [] | false | false | false | true | true | let va_ens_Fast_add1_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst_b inA_b: buffer64)
(inB_in: nat64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop =
| (va_req_Fast_add1_stdcall va_b0 va_s0 win dst_b inA_b inB_in /\
va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let dst_in:(va_int_range 0 18446744073709551615) =
(if win then va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0)
in
let inA_in:(va_int_range 0 18446744073709551615) =
(if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0)
in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let a2 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let a3 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in
let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in
let d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in
let d3 = Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in
let a = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d = Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in
d == a + inB_in /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\
(win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\
(win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\
(win ==> va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\
(win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\
(~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\
(~win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\
(~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\
va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM
(va_update_stackTaint va_sM
(va_update_stack va_sM
(va_update_mem_layout va_sM
(va_update_mem_heaplet 0
va_sM
(va_update_flags va_sM
(va_update_reg64 rR15
va_sM
(va_update_reg64 rR14
va_sM
(va_update_reg64 rR13
va_sM
(va_update_reg64 rR11
va_sM
(va_update_reg64 rR10
va_sM
(va_update_reg64 rR9
va_sM
(va_update_reg64 rR8
va_sM
(va_update_reg64 rRsp
va_sM
(va_update_reg64 rRbp
va_sM
(va_update_reg64 rRdi
va_sM
(va_update_reg64 rRsi
va_sM
(va_update_reg64 rRdx
va_sM
(va_update_reg64 rRcx
va_sM
(va_update_reg64 rRbx
va_sM
(va_update_reg64 rRax
va_sM
(va_update_ok va_sM
(va_update_mem
va_sM
va_s0)))
)))))))))))))))))))) | false |
Vale.Curve25519.X64.FastUtil.fsti | Vale.Curve25519.X64.FastUtil.va_req_Fast_add1_stdcall | val va_req_Fast_add1_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst_b inA_b: buffer64)
(inB_in: nat64)
: prop | val va_req_Fast_add1_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst_b inA_b: buffer64)
(inB_in: nat64)
: prop | let va_req_Fast_add1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) : prop =
(va_require_total va_b0 (va_code_Fast_add1_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret)) | {
"file_name": "obj/Vale.Curve25519.X64.FastUtil.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 12,
"end_line": 151,
"start_col": 0,
"start_line": 139
} | module Vale.Curve25519.X64.FastUtil
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Fast_add1
val va_code_Fast_add1 : va_dummy:unit -> Tot va_code
val va_codegen_success_Fast_add1 : va_dummy:unit -> Tot va_pbool
let va_req_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
: prop =
(va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0))
let va_ens_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1 va_b0 va_s0 dst_b inA_b inB /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fast_add1 : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
adx_enabled /\ bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0)
(va_get_mem va_s0) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rdx:nat64) (va_x_r8:nat64)
(va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64) (va_x_heap0:vale_heap)
(va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11
va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8
(va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) ==> va_k va_sM (())))
val va_wpProof_Fast_add1 : dst_b:buffer64 -> inA_b:buffer64 -> inB:nat64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_add1 dst_b inA_b inB va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_add1 ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) : (va_quickCode unit
(va_code_Fast_add1 ())) =
(va_QProc (va_code_Fast_add1 ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx;
va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fast_add1 dst_b inA_b inB) (va_wpProof_Fast_add1 dst_b
inA_b inB))
//--
//-- Fast_add1_stdcall
val va_code_Fast_add1_stdcall : win:bool -> Tot va_code | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastUtil.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
win: Prims.bool ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB_in: Vale.X64.Memory.nat64
-> Prims.prop | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Vale.X64.Memory.nat64",
"Prims.l_and",
"Vale.X64.Decls.va_require_total",
"Vale.Curve25519.X64.FastUtil.va_code_Fast_add1_stdcall",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.eq2",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Stack_i.init_rsp",
"Vale.X64.Decls.va_get_stack",
"Vale.X64.Memory.is_initial_heap",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Decls.va_get_mem",
"Vale.X64.CPU_Features_s.adx_enabled",
"Vale.X64.CPU_Features_s.bmi2_enabled",
"Prims.l_or",
"Vale.X64.Decls.buffers_disjoint",
"Prims.op_Equality",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Decls.validDstAddrs64",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validSrcAddrs64",
"Vale.X64.Decls.va_int_range",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRdi",
"Prims.prop"
] | [] | false | false | false | true | true | let va_req_Fast_add1_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst_b inA_b: buffer64)
(inB_in: nat64)
: prop =
| (va_require_total va_b0 (va_code_Fast_add1_stdcall win) va_s0 /\ va_get_ok va_s0 /\
(let dst_in:(va_int_range 0 18446744073709551615) =
(if win then va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0)
in
let inA_in:(va_int_range 0 18446744073709551615) =
(if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0)
in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
inB_in = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
dst_in
dst_b
4
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
inA_in
inA_b
4
(va_get_mem_layout va_s0)
Secret)) | false |
PulseCore.MonotonicStateMonad.fsti | PulseCore.MonotonicStateMonad.req_t | val req_t : s: Type -> Type | let req_t (s:Type) = s -> prop | {
"file_name": "lib/pulse_core/PulseCore.MonotonicStateMonad.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 30,
"end_line": 29,
"start_col": 0,
"start_line": 29
} | module PulseCore.MonotonicStateMonad
open FStar.Preorder
module M = FStar.MSTTotal
val mst (#s:Type u#s)
(rel:FStar.Preorder.preorder s)
(a:Type u#a)
(pre:s -> prop)
(post:s -> a -> s -> prop)
: Type u#(max a s)
val of_msttotal (#s:Type u#2) (rel:FStar.Preorder.preorder s)
(a:Type u#a) (pre:s -> prop) (post:s -> a -> s -> prop)
(f:unit -> M.MSTATETOT a s rel pre post)
: mst rel a pre post
val to_msttotal (#s:Type u#2) (rel:FStar.Preorder.preorder s)
(a:Type u#a) (pre:s -> prop) (post:s -> a -> s -> prop)
(f:mst rel a pre post)
: M.MSTATETOT a s rel pre post
val return (#s:Type u#s)
(#rel:preorder s)
(#a:Type u#a)
(x:a)
: mst rel a (fun _ -> True) (fun s0 v s1 -> x == v /\ s0 == s1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.MSTTotal.fst.checked"
],
"interface_file": false,
"source_file": "PulseCore.MonotonicStateMonad.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.MSTTotal",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.MSTTotal",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: Type -> Type | Prims.Tot | [
"total"
] | [] | [
"Prims.prop"
] | [] | false | false | false | true | true | let req_t (s: Type) =
| s -> prop | false |
|
PulseCore.MonotonicStateMonad.fsti | PulseCore.MonotonicStateMonad.ens_t | val ens_t : s: Type -> a: Type -> Type | let ens_t (s:Type) (a:Type) = s -> a -> s -> prop | {
"file_name": "lib/pulse_core/PulseCore.MonotonicStateMonad.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 49,
"end_line": 30,
"start_col": 0,
"start_line": 30
} | module PulseCore.MonotonicStateMonad
open FStar.Preorder
module M = FStar.MSTTotal
val mst (#s:Type u#s)
(rel:FStar.Preorder.preorder s)
(a:Type u#a)
(pre:s -> prop)
(post:s -> a -> s -> prop)
: Type u#(max a s)
val of_msttotal (#s:Type u#2) (rel:FStar.Preorder.preorder s)
(a:Type u#a) (pre:s -> prop) (post:s -> a -> s -> prop)
(f:unit -> M.MSTATETOT a s rel pre post)
: mst rel a pre post
val to_msttotal (#s:Type u#2) (rel:FStar.Preorder.preorder s)
(a:Type u#a) (pre:s -> prop) (post:s -> a -> s -> prop)
(f:mst rel a pre post)
: M.MSTATETOT a s rel pre post
val return (#s:Type u#s)
(#rel:preorder s)
(#a:Type u#a)
(x:a)
: mst rel a (fun _ -> True) (fun s0 v s1 -> x == v /\ s0 == s1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.MSTTotal.fst.checked"
],
"interface_file": false,
"source_file": "PulseCore.MonotonicStateMonad.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.MSTTotal",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.MSTTotal",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"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: Type -> a: Type -> Type | Prims.Tot | [
"total"
] | [] | [
"Prims.prop"
] | [] | false | false | false | true | true | let ens_t (s a: Type) =
| s -> a -> s -> prop | false |
|
Vale.Curve25519.X64.FastUtil.fsti | Vale.Curve25519.X64.FastUtil.va_quick_Fast_add1 | val va_quick_Fast_add1 (dst_b inA_b: buffer64) (inB: nat64)
: (va_quickCode unit (va_code_Fast_add1 ())) | val va_quick_Fast_add1 (dst_b inA_b: buffer64) (inB: nat64)
: (va_quickCode unit (va_code_Fast_add1 ())) | let va_quick_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) : (va_quickCode unit
(va_code_Fast_add1 ())) =
(va_QProc (va_code_Fast_add1 ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx;
va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fast_add1 dst_b inA_b inB) (va_wpProof_Fast_add1 dst_b
inA_b inB)) | {
"file_name": "obj/Vale.Curve25519.X64.FastUtil.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 132,
"start_col": 0,
"start_line": 127
} | module Vale.Curve25519.X64.FastUtil
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Fast_add1
val va_code_Fast_add1 : va_dummy:unit -> Tot va_code
val va_codegen_success_Fast_add1 : va_dummy:unit -> Tot va_pbool
let va_req_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
: prop =
(va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0))
let va_ens_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1 va_b0 va_s0 dst_b inA_b inB /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fast_add1 : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
adx_enabled /\ bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0)
(va_get_mem va_s0) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rdx:nat64) (va_x_r8:nat64)
(va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64) (va_x_heap0:vale_heap)
(va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11
va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8
(va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) ==> va_k va_sM (())))
val va_wpProof_Fast_add1 : dst_b:buffer64 -> inA_b:buffer64 -> inB:nat64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_add1 dst_b inA_b inB va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_add1 ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastUtil.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst_b: Vale.X64.Memory.buffer64 -> inA_b: Vale.X64.Memory.buffer64 -> inB: Vale.X64.Memory.nat64
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.Curve25519.X64.FastUtil.va_code_Fast_add1 ()) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Memory.buffer64",
"Vale.X64.Memory.nat64",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.Curve25519.X64.FastUtil.va_code_Fast_add1",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_Mod_mem_layout",
"Vale.X64.QuickCode.va_Mod_mem_heaplet",
"Vale.X64.QuickCode.va_Mod_reg64",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRax",
"Vale.X64.QuickCode.va_Mod_mem",
"Prims.Nil",
"Vale.Curve25519.X64.FastUtil.va_wp_Fast_add1",
"Vale.Curve25519.X64.FastUtil.va_wpProof_Fast_add1",
"Vale.X64.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Fast_add1 (dst_b inA_b: buffer64) (inB: nat64)
: (va_quickCode unit (va_code_Fast_add1 ())) =
| (va_QProc (va_code_Fast_add1 ())
([
va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10;
va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRax; va_Mod_mem
])
(va_wp_Fast_add1 dst_b inA_b inB)
(va_wpProof_Fast_add1 dst_b inA_b inB)) | false |
Vale.Curve25519.X64.FastUtil.fsti | Vale.Curve25519.X64.FastUtil.va_quick_Fast_add1_stdcall | val va_quick_Fast_add1_stdcall (win: bool) (dst_b inA_b: buffer64) (inB_in: nat64)
: (va_quickCode unit (va_code_Fast_add1_stdcall win)) | val va_quick_Fast_add1_stdcall (win: bool) (dst_b inA_b: buffer64) (inB_in: nat64)
: (va_quickCode unit (va_code_Fast_add1_stdcall win)) | let va_quick_Fast_add1_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_in:nat64) :
(va_quickCode unit (va_code_Fast_add1_stdcall win)) =
(va_QProc (va_code_Fast_add1_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fast_add1_stdcall win dst_b inA_b
inB_in) (va_wpProof_Fast_add1_stdcall win dst_b inA_b inB_in)) | {
"file_name": "obj/Vale.Curve25519.X64.FastUtil.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 66,
"end_line": 300,
"start_col": 0,
"start_line": 293
} | module Vale.Curve25519.X64.FastUtil
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Fast_add1
val va_code_Fast_add1 : va_dummy:unit -> Tot va_code
val va_codegen_success_Fast_add1 : va_dummy:unit -> Tot va_pbool
let va_req_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
: prop =
(va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0))
let va_ens_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1 va_b0 va_s0 dst_b inA_b inB /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fast_add1 : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
adx_enabled /\ bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0)
(va_get_mem va_s0) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rdx:nat64) (va_x_r8:nat64)
(va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64) (va_x_heap0:vale_heap)
(va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11
va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8
(va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) ==> va_k va_sM (())))
val va_wpProof_Fast_add1 : dst_b:buffer64 -> inA_b:buffer64 -> inB:nat64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_add1 dst_b inA_b inB va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_add1 ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) : (va_quickCode unit
(va_code_Fast_add1 ())) =
(va_QProc (va_code_Fast_add1 ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx;
va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fast_add1 dst_b inA_b inB) (va_wpProof_Fast_add1 dst_b
inA_b inB))
//--
//-- Fast_add1_stdcall
val va_code_Fast_add1_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fast_add1_stdcall : win:bool -> Tot va_pbool
let va_req_Fast_add1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) : prop =
(va_require_total va_b0 (va_code_Fast_add1_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret))
let va_ens_Fast_add1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1_stdcall va_b0 va_s0 win dst_b inA_b inB_in /\ va_ensure_total va_b0 va_s0 va_sM
va_fM /\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fast_add1_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_in:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_add1_stdcall win) va_s0 /\ va_get_ok va_s0 /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let a0 = Vale.X64.Decls.buffer64_read
inA_b 0 (va_get_mem va_s0) in let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0)
in let a2 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fast_add1_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_in:nat64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in =
va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rbx:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64) (va_x_rbp:nat64)
(va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64)
(va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let a0 =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) ==> va_k va_sM (())))
val va_wpProof_Fast_add1_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_in:nat64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_add1_stdcall win dst_b inA_b inB_in va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_add1_stdcall win)
([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags;
va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10;
va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi;
va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax;
va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastUtil.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
win: Prims.bool ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB_in: Vale.X64.Memory.nat64
-> Vale.X64.QuickCode.va_quickCode Prims.unit
(Vale.Curve25519.X64.FastUtil.va_code_Fast_add1_stdcall win) | Prims.Tot | [
"total"
] | [] | [
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Vale.X64.Memory.nat64",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.Curve25519.X64.FastUtil.va_code_Fast_add1_stdcall",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_stackTaint",
"Vale.X64.QuickCode.va_Mod_stack",
"Vale.X64.QuickCode.va_Mod_mem_layout",
"Vale.X64.QuickCode.va_Mod_mem_heaplet",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_Mod_reg64",
"Vale.X64.Machine_s.rR15",
"Vale.X64.Machine_s.rR14",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Machine_s.rRbp",
"Vale.X64.Machine_s.rRdi",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rRax",
"Vale.X64.QuickCode.va_Mod_mem",
"Prims.Nil",
"Vale.Curve25519.X64.FastUtil.va_wp_Fast_add1_stdcall",
"Vale.Curve25519.X64.FastUtil.va_wpProof_Fast_add1_stdcall",
"Vale.X64.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Fast_add1_stdcall (win: bool) (dst_b inA_b: buffer64) (inB_in: nat64)
: (va_quickCode unit (va_code_Fast_add1_stdcall win)) =
| (va_QProc (va_code_Fast_add1_stdcall win)
([
va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags;
va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11;
va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp;
va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem
])
(va_wp_Fast_add1_stdcall win dst_b inA_b inB_in)
(va_wpProof_Fast_add1_stdcall win dst_b inA_b inB_in)) | false |
Vale.Curve25519.X64.FastUtil.fsti | Vale.Curve25519.X64.FastUtil.va_quick_Cswap2 | val va_quick_Cswap2 (bit_in: nat64) (p0_b p1_b: buffer64) : (va_quickCode unit (va_code_Cswap2 ())) | val va_quick_Cswap2 (bit_in: nat64) (p0_b p1_b: buffer64) : (va_quickCode unit (va_code_Cswap2 ())) | let va_quick_Cswap2 (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64) : (va_quickCode unit
(va_code_Cswap2 ())) =
(va_QProc (va_code_Cswap2 ()) ([va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags;
va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdi; va_Mod_mem])
(va_wp_Cswap2 bit_in p0_b p1_b) (va_wpProof_Cswap2 bit_in p0_b p1_b)) | {
"file_name": "obj/Vale.Curve25519.X64.FastUtil.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 73,
"end_line": 562,
"start_col": 0,
"start_line": 558
} | module Vale.Curve25519.X64.FastUtil
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Fast_add1
val va_code_Fast_add1 : va_dummy:unit -> Tot va_code
val va_codegen_success_Fast_add1 : va_dummy:unit -> Tot va_pbool
let va_req_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
: prop =
(va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0))
let va_ens_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1 va_b0 va_s0 dst_b inA_b inB /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fast_add1 : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
adx_enabled /\ bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0)
(va_get_mem va_s0) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rdx:nat64) (va_x_r8:nat64)
(va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64) (va_x_heap0:vale_heap)
(va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11
va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8
(va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) ==> va_k va_sM (())))
val va_wpProof_Fast_add1 : dst_b:buffer64 -> inA_b:buffer64 -> inB:nat64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_add1 dst_b inA_b inB va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_add1 ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) : (va_quickCode unit
(va_code_Fast_add1 ())) =
(va_QProc (va_code_Fast_add1 ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx;
va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fast_add1 dst_b inA_b inB) (va_wpProof_Fast_add1 dst_b
inA_b inB))
//--
//-- Fast_add1_stdcall
val va_code_Fast_add1_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fast_add1_stdcall : win:bool -> Tot va_pbool
let va_req_Fast_add1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) : prop =
(va_require_total va_b0 (va_code_Fast_add1_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret))
let va_ens_Fast_add1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1_stdcall va_b0 va_s0 win dst_b inA_b inB_in /\ va_ensure_total va_b0 va_s0 va_sM
va_fM /\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fast_add1_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_in:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_add1_stdcall win) va_s0 /\ va_get_ok va_s0 /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let a0 = Vale.X64.Decls.buffer64_read
inA_b 0 (va_get_mem va_s0) in let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0)
in let a2 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fast_add1_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_in:nat64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in =
va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rbx:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64) (va_x_rbp:nat64)
(va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64)
(va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let a0 =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) ==> va_k va_sM (())))
val va_wpProof_Fast_add1_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_in:nat64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_add1_stdcall win dst_b inA_b inB_in va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_add1_stdcall win)
([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags;
va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10;
va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi;
va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax;
va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_add1_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_in:nat64) :
(va_quickCode unit (va_code_Fast_add1_stdcall win)) =
(va_QProc (va_code_Fast_add1_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fast_add1_stdcall win dst_b inA_b
inB_in) (va_wpProof_Fast_add1_stdcall win dst_b inA_b inB_in))
//--
//-- Cswap2
val va_code_Cswap2 : va_dummy:unit -> Tot va_code
val va_codegen_success_Cswap2 : va_dummy:unit -> Tot va_pbool
let va_req_Cswap2 (va_b0:va_code) (va_s0:va_state) (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64) :
prop =
(va_require_total va_b0 (va_code_Cswap2 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in
let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0)
in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem
va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3
(va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in let
(old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in
let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0)
in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem
va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3
(va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ bit_in == va_get_reg64 rRdi va_s0 /\
va_get_reg64 rRdi va_s0 <= 1 /\ (Vale.X64.Decls.buffers_disjoint p1_b p0_b \/ p1_b == p0_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRsi va_s0) p0_b 8
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdx va_s0) p1_b 8 (va_get_mem_layout va_s0) Secret))
let va_ens_Cswap2 (va_b0:va_code) (va_s0:va_state) (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Cswap2 va_b0 va_s0 bit_in p0_b p1_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0
(va_get_mem va_s0) in let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
1 (va_get_mem va_s0) in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 2 (va_get_mem va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_s0) in let
(old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in
let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0)
in let (old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem
va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0
(va_get_mem va_s0) in let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
1 (va_get_mem va_s0) in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 2 (va_get_mem va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_s0) in let
(old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in
let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0)
in let (old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem
va_s0) in Vale.X64.Decls.modifies_buffer_2 p0_b p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\
(let p0_0 = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_sM) in let p0_1 =
Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let p0_2 =
Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == (if (va_get_reg64 rRdi va_s0
= 1) then old_p1_0 else old_p0_0) /\ p0_1 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_1
else old_p0_1) /\ p0_2 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_2 else old_p0_2) /\
p0_3 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_3 else old_p0_3) /\ p0_4 == (if
(va_get_reg64 rRdi va_s0 = 1) then old_p1_4 else old_p0_4) /\ p0_5 == (if (va_get_reg64 rRdi
va_s0 = 1) then old_p1_5 else old_p0_5) /\ p0_6 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p1_6 else old_p0_6) /\ p0_7 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_7 else
old_p0_7) /\ p1_0 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_0 else old_p1_0) /\ p1_1 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_1 else old_p1_1) /\ p1_2 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_2 else old_p1_2) /\ p1_3 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p0_3 else old_p1_3) /\ p1_4 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_4 else
old_p1_4) /\ p1_5 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_5 else old_p1_5) /\ p1_6 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_6 else old_p1_6) /\ p1_7 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_7 else old_p1_7))) /\ va_state_eq va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdi va_sM (va_update_ok
va_sM (va_update_mem va_sM va_s0))))))))))
val va_lemma_Cswap2 : va_b0:va_code -> va_s0:va_state -> bit_in:nat64 -> p0_b:buffer64 ->
p1_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Cswap2 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in
let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0)
in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem
va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3
(va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in let
(old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in
let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0)
in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem
va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3
(va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ bit_in == va_get_reg64 rRdi va_s0 /\
va_get_reg64 rRdi va_s0 <= 1 /\ (Vale.X64.Decls.buffers_disjoint p1_b p0_b \/ p1_b == p0_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRsi va_s0) p0_b 8
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdx va_s0) p1_b 8 (va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0)
in let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem
va_s0) in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2
(va_get_mem va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
3 (va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let
(old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in
let (old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0)
in let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem
va_s0) in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2
(va_get_mem va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
3 (va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let
(old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in
Vale.X64.Decls.modifies_buffer_2 p0_b p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (let p0_0 =
Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_sM) in let p0_1 =
Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let p0_2 =
Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == (if (va_get_reg64 rRdi va_s0
= 1) then old_p1_0 else old_p0_0) /\ p0_1 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_1
else old_p0_1) /\ p0_2 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_2 else old_p0_2) /\
p0_3 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_3 else old_p0_3) /\ p0_4 == (if
(va_get_reg64 rRdi va_s0 = 1) then old_p1_4 else old_p0_4) /\ p0_5 == (if (va_get_reg64 rRdi
va_s0 = 1) then old_p1_5 else old_p0_5) /\ p0_6 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p1_6 else old_p0_6) /\ p0_7 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_7 else
old_p0_7) /\ p1_0 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_0 else old_p1_0) /\ p1_1 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_1 else old_p1_1) /\ p1_2 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_2 else old_p1_2) /\ p1_3 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p0_3 else old_p1_3) /\ p1_4 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_4 else
old_p1_4) /\ p1_5 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_5 else old_p1_5) /\ p1_6 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_6 else old_p1_6) /\ p1_7 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_7 else old_p1_7))) /\ va_state_eq va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdi va_sM (va_update_ok
va_sM (va_update_mem va_sM va_s0)))))))))))
[@ va_qattr]
let va_wp_Cswap2 (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0
(va_get_mem va_s0) in let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
1 (va_get_mem va_s0) in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 2 (va_get_mem va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_s0) in let
(old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in
let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0)
in let (old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem
va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0
(va_get_mem va_s0) in let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
1 (va_get_mem va_s0) in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 2 (va_get_mem va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_s0) in let
(old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in
let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0)
in let (old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem
va_s0) in Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
bit_in == va_get_reg64 rRdi va_s0 /\ va_get_reg64 rRdi va_s0 <= 1 /\
(Vale.X64.Decls.buffers_disjoint p1_b p0_b \/ p1_b == p0_b) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) p0_b 8 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) p1_b 8
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rdi:nat64)
(va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) . let va_sM = va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags va_x_efl (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdi va_x_rdi
(va_upd_mem va_x_mem va_s0))))))) in va_get_ok va_sM /\ (let (old_p0_0:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in let
(old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0) in
let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_s0)
in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem
va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 4
(va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in let
(old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0) in
let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_s0)
in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem
va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 4
(va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in Vale.X64.Decls.modifies_buffer_2 p0_b
p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (let p0_0 = Vale.X64.Decls.buffer64_read p0_b 0
(va_get_mem va_sM) in let p0_1 = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let
p0_2 = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == va_if (va_get_reg64 rRdi
va_s0 = 1) (fun _ -> old_p1_0) (fun _ -> old_p0_0) /\ p0_1 == va_if (va_get_reg64 rRdi va_s0 =
1) (fun _ -> old_p1_1) (fun _ -> old_p0_1) /\ p0_2 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun
_ -> old_p1_2) (fun _ -> old_p0_2) /\ p0_3 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_3) (fun _ -> old_p0_3) /\ p0_4 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_4) (fun _ -> old_p0_4) /\ p0_5 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_5) (fun _ -> old_p0_5) /\ p0_6 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_6) (fun _ -> old_p0_6) /\ p0_7 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_7) (fun _ -> old_p0_7) /\ p1_0 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_0) (fun _ -> old_p1_0) /\ p1_1 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_1) (fun _ -> old_p1_1) /\ p1_2 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_2) (fun _ -> old_p1_2) /\ p1_3 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_3) (fun _ -> old_p1_3) /\ p1_4 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_4) (fun _ -> old_p1_4) /\ p1_5 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_5) (fun _ -> old_p1_5) /\ p1_6 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_6) (fun _ -> old_p1_6) /\ p1_7 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_7) (fun _ -> old_p1_7))) ==> va_k va_sM (())))
val va_wpProof_Cswap2 : bit_in:nat64 -> p0_b:buffer64 -> p1_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Cswap2 bit_in p0_b p1_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Cswap2 ()) ([va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdi; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastUtil.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | bit_in: Vale.X64.Memory.nat64 -> p0_b: Vale.X64.Memory.buffer64 -> p1_b: Vale.X64.Memory.buffer64
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.Curve25519.X64.FastUtil.va_code_Cswap2 ()) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Memory.nat64",
"Vale.X64.Memory.buffer64",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.Curve25519.X64.FastUtil.va_code_Cswap2",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_mem_layout",
"Vale.X64.QuickCode.va_Mod_mem_heaplet",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_Mod_reg64",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRdi",
"Vale.X64.QuickCode.va_Mod_mem",
"Prims.Nil",
"Vale.Curve25519.X64.FastUtil.va_wp_Cswap2",
"Vale.Curve25519.X64.FastUtil.va_wpProof_Cswap2",
"Vale.X64.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Cswap2 (bit_in: nat64) (p0_b p1_b: buffer64) : (va_quickCode unit (va_code_Cswap2 ())) =
| (va_QProc (va_code_Cswap2 ())
([
va_Mod_mem_layout;
va_Mod_mem_heaplet 0;
va_Mod_flags;
va_Mod_reg64 rR10;
va_Mod_reg64 rR9;
va_Mod_reg64 rR8;
va_Mod_reg64 rRdi;
va_Mod_mem
])
(va_wp_Cswap2 bit_in p0_b p1_b)
(va_wpProof_Cswap2 bit_in p0_b p1_b)) | false |
Vale.Curve25519.X64.FastUtil.fsti | Vale.Curve25519.X64.FastUtil.va_wp_Fast_add1_stdcall | val va_wp_Fast_add1_stdcall
(win: bool)
(dst_b inA_b: buffer64)
(inB_in: nat64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Fast_add1_stdcall
(win: bool)
(dst_b inA_b: buffer64)
(inB_in: nat64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Fast_add1_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_in:nat64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in =
va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rbx:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64) (va_x_rbp:nat64)
(va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64)
(va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let a0 =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.Curve25519.X64.FastUtil.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 50,
"end_line": 280,
"start_col": 0,
"start_line": 233
} | module Vale.Curve25519.X64.FastUtil
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Fast_add1
val va_code_Fast_add1 : va_dummy:unit -> Tot va_code
val va_codegen_success_Fast_add1 : va_dummy:unit -> Tot va_pbool
let va_req_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
: prop =
(va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0))
let va_ens_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1 va_b0 va_s0 dst_b inA_b inB /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fast_add1 : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
adx_enabled /\ bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0)
(va_get_mem va_s0) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rdx:nat64) (va_x_r8:nat64)
(va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64) (va_x_heap0:vale_heap)
(va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11
va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8
(va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) ==> va_k va_sM (())))
val va_wpProof_Fast_add1 : dst_b:buffer64 -> inA_b:buffer64 -> inB:nat64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_add1 dst_b inA_b inB va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_add1 ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) : (va_quickCode unit
(va_code_Fast_add1 ())) =
(va_QProc (va_code_Fast_add1 ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx;
va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fast_add1 dst_b inA_b inB) (va_wpProof_Fast_add1 dst_b
inA_b inB))
//--
//-- Fast_add1_stdcall
val va_code_Fast_add1_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fast_add1_stdcall : win:bool -> Tot va_pbool
let va_req_Fast_add1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) : prop =
(va_require_total va_b0 (va_code_Fast_add1_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret))
let va_ens_Fast_add1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1_stdcall va_b0 va_s0 win dst_b inA_b inB_in /\ va_ensure_total va_b0 va_s0 va_sM
va_fM /\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fast_add1_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_in:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_add1_stdcall win) va_s0 /\ va_get_ok va_s0 /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let a0 = Vale.X64.Decls.buffer64_read
inA_b 0 (va_get_mem va_s0) in let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0)
in let a2 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))))))))))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastUtil.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
win: Prims.bool ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB_in: Vale.X64.Memory.nat64 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Vale.X64.Memory.nat64",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.eq2",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Stack_i.init_rsp",
"Vale.X64.Decls.va_get_stack",
"Vale.X64.Memory.is_initial_heap",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Decls.va_get_mem",
"Vale.X64.CPU_Features_s.adx_enabled",
"Vale.X64.CPU_Features_s.bmi2_enabled",
"Prims.l_or",
"Vale.X64.Decls.buffers_disjoint",
"Prims.op_Equality",
"Vale.X64.Decls.va_if",
"Vale.Def.Types_s.nat64",
"Vale.X64.Machine_s.rR8",
"Prims.l_not",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Decls.validDstAddrs64",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validSrcAddrs64",
"Vale.X64.Decls.va_int_range",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRdi",
"Prims.l_Forall",
"Vale.X64.InsBasic.vale_heap",
"Vale.X64.Flags.t",
"Vale.Arch.HeapImpl.vale_heap_layout",
"Vale.X64.InsBasic.vale_stack",
"Vale.X64.Memory.memtaint",
"Prims.l_imp",
"Prims.int",
"Prims.op_Addition",
"Vale.X64.Decls.modifies_buffer",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rRbp",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rR14",
"Vale.X64.Machine_s.rR15",
"Prims.nat",
"Vale.Curve25519.Fast_defs.pow2_five",
"Vale.X64.Machine_s.rRax",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.X64.Decls.buffer64_read",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_stackTaint",
"Vale.X64.Decls.va_upd_stack",
"Vale.X64.Decls.va_upd_mem_layout",
"Vale.X64.Decls.va_upd_mem_heaplet",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_reg64",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Decls.va_upd_mem"
] | [] | false | false | false | true | true | let va_wp_Fast_add1_stdcall
(win: bool)
(dst_b inA_b: buffer64)
(inB_in: nat64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_get_ok va_s0 /\
(let dst_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0)
in
let inA_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0)
in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
inB_in = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
dst_in
dst_b
4
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
inA_in
inA_b
4
(va_get_mem_layout va_s0)
Secret) /\
(forall (va_x_mem: vale_heap) (va_x_rax: nat64) (va_x_rbx: nat64) (va_x_rcx: nat64)
(va_x_rdx: nat64) (va_x_rsi: nat64) (va_x_rdi: nat64) (va_x_rbp: nat64) (va_x_rsp: nat64)
(va_x_r8: nat64) (va_x_r9: nat64) (va_x_r10: nat64) (va_x_r11: nat64) (va_x_r13: nat64)
(va_x_r14: nat64) (va_x_r15: nat64) (va_x_efl: Vale.X64.Flags.t) (va_x_heap0: vale_heap)
(va_x_memLayout: vale_heap_layout) (va_x_stack: vale_stack) (va_x_stackTaint: memtaint).
let va_sM =
va_upd_stackTaint va_x_stackTaint
(va_upd_stack va_x_stack
(va_upd_mem_layout va_x_memLayout
(va_upd_mem_heaplet 0
va_x_heap0
(va_upd_flags va_x_efl
(va_upd_reg64 rR15
va_x_r15
(va_upd_reg64 rR14
va_x_r14
(va_upd_reg64 rR13
va_x_r13
(va_upd_reg64 rR11
va_x_r11
(va_upd_reg64 rR10
va_x_r10
(va_upd_reg64 rR9
va_x_r9
(va_upd_reg64 rR8
va_x_r8
(va_upd_reg64 rRsp
va_x_rsp
(va_upd_reg64 rRbp
va_x_rbp
(va_upd_reg64 rRdi
va_x_rdi
(va_upd_reg64 rRsi
va_x_rsi
(va_upd_reg64 rRdx
va_x_rdx
(va_upd_reg64 rRcx
va_x_rcx
(va_upd_reg64 rRbx
va_x_rbx
(va_upd_reg64 rRax
va_x_rax
(va_upd_mem va_x_mem
va_s0)))))
)))))))))))))))
in
va_get_ok va_sM /\
(let dst_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0)
in
let inA_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0)
in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let a2 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let a3 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in
let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in
let d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in
let d3 = Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in
let a = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d = Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in
d == a + inB_in /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\
(win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\
(win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\
(win ==> va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\
(win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\
(~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\
(~win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\
(~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\
va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (()))) | false |
Vale.AES.GCTR_s.fst | Vale.AES.GCTR_s.is_gctr_plain_LE | val is_gctr_plain_LE (p: seq nat8) : prop0 | val is_gctr_plain_LE (p: seq nat8) : prop0 | let is_gctr_plain_LE (p:seq nat8) : prop0 = length p < pow2_32 | {
"file_name": "vale/specs/crypto/Vale.AES.GCTR_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 62,
"end_line": 16,
"start_col": 0,
"start_line": 16
} | module Vale.AES.GCTR_s
// IMPORTANT: Following NIST's specification, this spec is written assuming a big-endian mapping from bytes to quad32s
// Since the AES spec (AES_s) is in little-endian, we need to byteswap each time we call AES
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
open Vale.AES.AES_s
open FStar.Seq
// The max length of pow2_32 corresponds to the max length of buffers in Low* | {
"checked_file": "/",
"dependencies": [
"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.AES.AES_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.GCTR_s.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: FStar.Seq.Base.seq Vale.Def.Types_s.nat8 -> Vale.Def.Prop_s.prop0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat8",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Vale.Def.Words_s.pow2_32",
"Vale.Def.Prop_s.prop0"
] | [] | false | false | false | true | false | let is_gctr_plain_LE (p: seq nat8) : prop0 =
| length p < pow2_32 | false |
Vale.AES.GCTR_s.fst | Vale.AES.GCTR_s.gctr_encrypt_LE | val gctr_encrypt_LE : icb_BE: Vale.Def.Types_s.quad32 ->
plain: FStar.Seq.Base.seq Vale.Def.Types_s.nat8 ->
alg: Vale.AES.AES_common_s.algorithm ->
key: FStar.Seq.Base.seq Vale.Def.Types_s.nat32
-> Prims.Pure (FStar.Seq.Base.seq Vale.Def.Types_s.nat8) | let gctr_encrypt_LE = opaque_make gctr_encrypt_LE_def | {
"file_name": "vale/specs/crypto/Vale.AES.GCTR_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 73,
"end_line": 70,
"start_col": 19,
"start_line": 70
} | module Vale.AES.GCTR_s
// IMPORTANT: Following NIST's specification, this spec is written assuming a big-endian mapping from bytes to quad32s
// Since the AES spec (AES_s) is in little-endian, we need to byteswap each time we call AES
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
open Vale.AES.AES_s
open FStar.Seq
// The max length of pow2_32 corresponds to the max length of buffers in Low*
// length plain < pow2_32 <= spec max of 2**39 - 256;
let is_gctr_plain_LE (p:seq nat8) : prop0 = length p < pow2_32
type gctr_plain_LE:eqtype = p:seq nat8 { is_gctr_plain_LE p }
type gctr_plain_internal_LE:eqtype = seq quad32
let inc32 (cb:quad32) (i:int) : quad32 =
Mkfour ((cb.lo0 + i) % pow2_32) cb.lo1 cb.hi2 cb.hi3
let gctr_encrypt_block (icb_BE:quad32) (plain_LE:quad32) (alg:algorithm) (key:seq nat32) (i:int) : Pure quad32
(requires is_aes_key_LE alg key)
(ensures fun _ -> True)
=
let icb_LE = reverse_bytes_quad32 (inc32 icb_BE i) in
quad32_xor plain_LE (aes_encrypt_LE alg key icb_LE)
let rec gctr_encrypt_recursive (icb_BE:quad32) (plain:gctr_plain_internal_LE)
(alg:algorithm) (key:aes_key_LE alg) (i:int) : Tot (seq quad32) (decreases %[length plain]) =
if length plain = 0 then empty
else
cons (gctr_encrypt_block icb_BE (head plain) alg key i) (gctr_encrypt_recursive icb_BE (tail plain) alg key (i + 1))
let pad_to_128_bits (p:seq nat8) : Pure (seq nat8)
(requires True)
(ensures fun q -> length q % 16 == 0 /\ length q <= length p + 15)
=
let num_extra_bytes = length p % 16 in
if num_extra_bytes = 0 then p
else p @| (create (16 - num_extra_bytes) 0)
// little-endian, except for icb_BE
let gctr_encrypt_LE_def (icb_BE:quad32) (plain:seq nat8) (alg:algorithm) (key:seq nat32) : Pure (seq nat8)
(requires is_gctr_plain_LE plain /\ is_aes_key_LE alg key)
(ensures fun _ -> True)
=
let num_extra = (length plain) % 16 in
if num_extra = 0 then
let plain_quads_LE = le_bytes_to_seq_quad32 plain in
let cipher_quads_LE = gctr_encrypt_recursive icb_BE plain_quads_LE alg key 0 in
le_seq_quad32_to_bytes cipher_quads_LE
else
let full_bytes_len = (length plain) - num_extra in
let full_blocks, final_block = split plain full_bytes_len in
let full_quads_LE = le_bytes_to_seq_quad32 full_blocks in
let final_quad_LE = le_bytes_to_quad32 (pad_to_128_bits final_block) in
let cipher_quads_LE = gctr_encrypt_recursive icb_BE full_quads_LE alg key 0 in
let final_cipher_quad_LE = gctr_encrypt_block icb_BE final_quad_LE alg key (full_bytes_len / 16) in
let cipher_bytes_full_LE = le_seq_quad32_to_bytes cipher_quads_LE in
let final_cipher_bytes_LE = slice (le_quad32_to_bytes final_cipher_quad_LE) 0 num_extra in | {
"checked_file": "/",
"dependencies": [
"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.AES.AES_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.GCTR_s.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
icb_BE: Vale.Def.Types_s.quad32 ->
plain: FStar.Seq.Base.seq Vale.Def.Types_s.nat8 ->
alg: Vale.AES.AES_common_s.algorithm ->
key: FStar.Seq.Base.seq Vale.Def.Types_s.nat32
-> Prims.Pure (FStar.Seq.Base.seq Vale.Def.Types_s.nat8) | Prims.Pure | [] | [] | [
"Vale.Def.Opaque_s.opaque_make",
"Vale.Def.Types_s.quad32",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat8",
"Vale.AES.AES_common_s.algorithm",
"Vale.Def.Types_s.nat32",
"Prims.l_and",
"Vale.AES.GCTR_s.is_gctr_plain_LE",
"Vale.AES.AES_s.is_aes_key_LE",
"Prims.l_True",
"Vale.AES.GCTR_s.gctr_encrypt_LE_def"
] | [] | false | false | false | false | false | let gctr_encrypt_LE =
| opaque_make gctr_encrypt_LE_def | false |
|
Vale.Curve25519.X64.FastUtil.fsti | Vale.Curve25519.X64.FastUtil.va_quick_Cswap2_stdcall | val va_quick_Cswap2_stdcall (win: bool) (bit_in: nat64) (p0_b p1_b: buffer64)
: (va_quickCode unit (va_code_Cswap2_stdcall win)) | val va_quick_Cswap2_stdcall (win: bool) (bit_in: nat64) (p0_b p1_b: buffer64)
: (va_quickCode unit (va_code_Cswap2_stdcall win)) | let va_quick_Cswap2_stdcall (win:bool) (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64) :
(va_quickCode unit (va_code_Cswap2_stdcall win)) =
(va_QProc (va_code_Cswap2_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRsp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_mem])
(va_wp_Cswap2_stdcall win bit_in p0_b p1_b) (va_wpProof_Cswap2_stdcall win bit_in p0_b p1_b)) | {
"file_name": "obj/Vale.Curve25519.X64.FastUtil.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 97,
"end_line": 847,
"start_col": 0,
"start_line": 842
} | module Vale.Curve25519.X64.FastUtil
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Fast_add1
val va_code_Fast_add1 : va_dummy:unit -> Tot va_code
val va_codegen_success_Fast_add1 : va_dummy:unit -> Tot va_pbool
let va_req_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
: prop =
(va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0))
let va_ens_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1 va_b0 va_s0 dst_b inA_b inB /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fast_add1 : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
adx_enabled /\ bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0)
(va_get_mem va_s0) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rdx:nat64) (va_x_r8:nat64)
(va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64) (va_x_heap0:vale_heap)
(va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11
va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8
(va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) ==> va_k va_sM (())))
val va_wpProof_Fast_add1 : dst_b:buffer64 -> inA_b:buffer64 -> inB:nat64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_add1 dst_b inA_b inB va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_add1 ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) : (va_quickCode unit
(va_code_Fast_add1 ())) =
(va_QProc (va_code_Fast_add1 ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx;
va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fast_add1 dst_b inA_b inB) (va_wpProof_Fast_add1 dst_b
inA_b inB))
//--
//-- Fast_add1_stdcall
val va_code_Fast_add1_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fast_add1_stdcall : win:bool -> Tot va_pbool
let va_req_Fast_add1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) : prop =
(va_require_total va_b0 (va_code_Fast_add1_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret))
let va_ens_Fast_add1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1_stdcall va_b0 va_s0 win dst_b inA_b inB_in /\ va_ensure_total va_b0 va_s0 va_sM
va_fM /\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fast_add1_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_in:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_add1_stdcall win) va_s0 /\ va_get_ok va_s0 /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let a0 = Vale.X64.Decls.buffer64_read
inA_b 0 (va_get_mem va_s0) in let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0)
in let a2 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fast_add1_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_in:nat64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in =
va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rbx:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64) (va_x_rbp:nat64)
(va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64)
(va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let a0 =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) ==> va_k va_sM (())))
val va_wpProof_Fast_add1_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_in:nat64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_add1_stdcall win dst_b inA_b inB_in va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_add1_stdcall win)
([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags;
va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10;
va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi;
va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax;
va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_add1_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_in:nat64) :
(va_quickCode unit (va_code_Fast_add1_stdcall win)) =
(va_QProc (va_code_Fast_add1_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fast_add1_stdcall win dst_b inA_b
inB_in) (va_wpProof_Fast_add1_stdcall win dst_b inA_b inB_in))
//--
//-- Cswap2
val va_code_Cswap2 : va_dummy:unit -> Tot va_code
val va_codegen_success_Cswap2 : va_dummy:unit -> Tot va_pbool
let va_req_Cswap2 (va_b0:va_code) (va_s0:va_state) (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64) :
prop =
(va_require_total va_b0 (va_code_Cswap2 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in
let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0)
in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem
va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3
(va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in let
(old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in
let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0)
in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem
va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3
(va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ bit_in == va_get_reg64 rRdi va_s0 /\
va_get_reg64 rRdi va_s0 <= 1 /\ (Vale.X64.Decls.buffers_disjoint p1_b p0_b \/ p1_b == p0_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRsi va_s0) p0_b 8
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdx va_s0) p1_b 8 (va_get_mem_layout va_s0) Secret))
let va_ens_Cswap2 (va_b0:va_code) (va_s0:va_state) (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Cswap2 va_b0 va_s0 bit_in p0_b p1_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0
(va_get_mem va_s0) in let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
1 (va_get_mem va_s0) in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 2 (va_get_mem va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_s0) in let
(old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in
let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0)
in let (old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem
va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0
(va_get_mem va_s0) in let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
1 (va_get_mem va_s0) in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 2 (va_get_mem va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_s0) in let
(old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in
let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0)
in let (old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem
va_s0) in Vale.X64.Decls.modifies_buffer_2 p0_b p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\
(let p0_0 = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_sM) in let p0_1 =
Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let p0_2 =
Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == (if (va_get_reg64 rRdi va_s0
= 1) then old_p1_0 else old_p0_0) /\ p0_1 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_1
else old_p0_1) /\ p0_2 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_2 else old_p0_2) /\
p0_3 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_3 else old_p0_3) /\ p0_4 == (if
(va_get_reg64 rRdi va_s0 = 1) then old_p1_4 else old_p0_4) /\ p0_5 == (if (va_get_reg64 rRdi
va_s0 = 1) then old_p1_5 else old_p0_5) /\ p0_6 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p1_6 else old_p0_6) /\ p0_7 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_7 else
old_p0_7) /\ p1_0 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_0 else old_p1_0) /\ p1_1 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_1 else old_p1_1) /\ p1_2 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_2 else old_p1_2) /\ p1_3 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p0_3 else old_p1_3) /\ p1_4 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_4 else
old_p1_4) /\ p1_5 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_5 else old_p1_5) /\ p1_6 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_6 else old_p1_6) /\ p1_7 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_7 else old_p1_7))) /\ va_state_eq va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdi va_sM (va_update_ok
va_sM (va_update_mem va_sM va_s0))))))))))
val va_lemma_Cswap2 : va_b0:va_code -> va_s0:va_state -> bit_in:nat64 -> p0_b:buffer64 ->
p1_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Cswap2 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in
let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0)
in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem
va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3
(va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in let
(old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in
let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0)
in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem
va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3
(va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ bit_in == va_get_reg64 rRdi va_s0 /\
va_get_reg64 rRdi va_s0 <= 1 /\ (Vale.X64.Decls.buffers_disjoint p1_b p0_b \/ p1_b == p0_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRsi va_s0) p0_b 8
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdx va_s0) p1_b 8 (va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0)
in let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem
va_s0) in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2
(va_get_mem va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
3 (va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let
(old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in
let (old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0)
in let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem
va_s0) in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2
(va_get_mem va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
3 (va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let
(old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in
Vale.X64.Decls.modifies_buffer_2 p0_b p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (let p0_0 =
Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_sM) in let p0_1 =
Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let p0_2 =
Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == (if (va_get_reg64 rRdi va_s0
= 1) then old_p1_0 else old_p0_0) /\ p0_1 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_1
else old_p0_1) /\ p0_2 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_2 else old_p0_2) /\
p0_3 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_3 else old_p0_3) /\ p0_4 == (if
(va_get_reg64 rRdi va_s0 = 1) then old_p1_4 else old_p0_4) /\ p0_5 == (if (va_get_reg64 rRdi
va_s0 = 1) then old_p1_5 else old_p0_5) /\ p0_6 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p1_6 else old_p0_6) /\ p0_7 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_7 else
old_p0_7) /\ p1_0 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_0 else old_p1_0) /\ p1_1 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_1 else old_p1_1) /\ p1_2 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_2 else old_p1_2) /\ p1_3 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p0_3 else old_p1_3) /\ p1_4 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_4 else
old_p1_4) /\ p1_5 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_5 else old_p1_5) /\ p1_6 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_6 else old_p1_6) /\ p1_7 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_7 else old_p1_7))) /\ va_state_eq va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdi va_sM (va_update_ok
va_sM (va_update_mem va_sM va_s0)))))))))))
[@ va_qattr]
let va_wp_Cswap2 (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0
(va_get_mem va_s0) in let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
1 (va_get_mem va_s0) in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 2 (va_get_mem va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_s0) in let
(old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in
let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0)
in let (old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem
va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0
(va_get_mem va_s0) in let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
1 (va_get_mem va_s0) in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 2 (va_get_mem va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_s0) in let
(old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in
let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0)
in let (old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem
va_s0) in Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
bit_in == va_get_reg64 rRdi va_s0 /\ va_get_reg64 rRdi va_s0 <= 1 /\
(Vale.X64.Decls.buffers_disjoint p1_b p0_b \/ p1_b == p0_b) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) p0_b 8 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) p1_b 8
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rdi:nat64)
(va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) . let va_sM = va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags va_x_efl (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdi va_x_rdi
(va_upd_mem va_x_mem va_s0))))))) in va_get_ok va_sM /\ (let (old_p0_0:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in let
(old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0) in
let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_s0)
in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem
va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 4
(va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in let
(old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0) in
let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_s0)
in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem
va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 4
(va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in Vale.X64.Decls.modifies_buffer_2 p0_b
p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (let p0_0 = Vale.X64.Decls.buffer64_read p0_b 0
(va_get_mem va_sM) in let p0_1 = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let
p0_2 = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == va_if (va_get_reg64 rRdi
va_s0 = 1) (fun _ -> old_p1_0) (fun _ -> old_p0_0) /\ p0_1 == va_if (va_get_reg64 rRdi va_s0 =
1) (fun _ -> old_p1_1) (fun _ -> old_p0_1) /\ p0_2 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun
_ -> old_p1_2) (fun _ -> old_p0_2) /\ p0_3 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_3) (fun _ -> old_p0_3) /\ p0_4 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_4) (fun _ -> old_p0_4) /\ p0_5 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_5) (fun _ -> old_p0_5) /\ p0_6 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_6) (fun _ -> old_p0_6) /\ p0_7 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_7) (fun _ -> old_p0_7) /\ p1_0 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_0) (fun _ -> old_p1_0) /\ p1_1 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_1) (fun _ -> old_p1_1) /\ p1_2 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_2) (fun _ -> old_p1_2) /\ p1_3 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_3) (fun _ -> old_p1_3) /\ p1_4 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_4) (fun _ -> old_p1_4) /\ p1_5 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_5) (fun _ -> old_p1_5) /\ p1_6 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_6) (fun _ -> old_p1_6) /\ p1_7 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_7) (fun _ -> old_p1_7))) ==> va_k va_sM (())))
val va_wpProof_Cswap2 : bit_in:nat64 -> p0_b:buffer64 -> p1_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Cswap2 bit_in p0_b p1_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Cswap2 ()) ([va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdi; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Cswap2 (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64) : (va_quickCode unit
(va_code_Cswap2 ())) =
(va_QProc (va_code_Cswap2 ()) ([va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags;
va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdi; va_Mod_mem])
(va_wp_Cswap2 bit_in p0_b p1_b) (va_wpProof_Cswap2 bit_in p0_b p1_b))
//--
//-- Cswap2_stdcall
val va_code_Cswap2_stdcall : win:bool -> Tot va_code
val va_codegen_success_Cswap2_stdcall : win:bool -> Tot va_pbool
let va_req_Cswap2_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (bit_in:nat64)
(p0_b:buffer64) (p1_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Cswap2_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(p0_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else
va_get_reg64 rRsi va_s0) in let (p1_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in let (old_p0_0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in let (old_p0_1:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0) in let
(old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_s0) in
let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0)
in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem
va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 5
(va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 7 (va_get_mem va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in let (old_p1_1:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0) in let
(old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_s0) in
let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0)
in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem
va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 5
(va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 7 (va_get_mem va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack
va_s0) /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
bit_in <= 1 /\ bit_in = (if win then va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) /\
(Vale.X64.Decls.buffers_disjoint p0_b p1_b \/ p1_b == p0_b) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) p0_in p0_b 8 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) p1_in p1_b 8 (va_get_mem_layout va_s0)
Secret))
let va_ens_Cswap2_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (bit_in:nat64)
(p0_b:buffer64) (p1_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Cswap2_stdcall va_b0 va_s0 win bit_in p0_b p1_b /\ va_ensure_total va_b0 va_s0 va_sM
va_fM /\ va_get_ok va_sM /\ (let (p0_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (p1_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let (old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0)
in let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem
va_s0) in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2
(va_get_mem va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
3 (va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let
(old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in
let (old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0)
in let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem
va_s0) in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2
(va_get_mem va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
3 (va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let
(old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in
let p0_0 = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_sM) in let p0_1 =
Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let p0_2 =
Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == (if (bit_in = 1) then
old_p1_0 else old_p0_0) /\ p0_1 == (if (bit_in = 1) then old_p1_1 else old_p0_1) /\ p0_2 == (if
(bit_in = 1) then old_p1_2 else old_p0_2) /\ p0_3 == (if (bit_in = 1) then old_p1_3 else
old_p0_3) /\ p0_4 == (if (bit_in = 1) then old_p1_4 else old_p0_4) /\ p0_5 == (if (bit_in = 1)
then old_p1_5 else old_p0_5) /\ p0_6 == (if (bit_in = 1) then old_p1_6 else old_p0_6) /\ p0_7
== (if (bit_in = 1) then old_p1_7 else old_p0_7) /\ p1_0 == (if (bit_in = 1) then old_p0_0 else
old_p1_0) /\ p1_1 == (if (bit_in = 1) then old_p0_1 else old_p1_1) /\ p1_2 == (if (bit_in = 1)
then old_p0_2 else old_p1_2) /\ p1_3 == (if (bit_in = 1) then old_p0_3 else old_p1_3) /\ p1_4
== (if (bit_in = 1) then old_p0_4 else old_p1_4) /\ p1_5 == (if (bit_in = 1) then old_p0_5 else
old_p1_5) /\ p1_6 == (if (bit_in = 1) then old_p0_6 else old_p1_6) /\ p1_7 == (if (bit_in = 1)
then old_p0_7 else old_p1_7) /\ Vale.X64.Decls.modifies_buffer_2 p0_b p1_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==>
va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64
rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM
(va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM
(va_update_reg64 rRdx va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))))
val va_lemma_Cswap2_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> bit_in:nat64 ->
p0_b:buffer64 -> p1_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Cswap2_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(p0_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else
va_get_reg64 rRsi va_s0) in let (p1_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in let (old_p0_0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in let (old_p0_1:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0) in let
(old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_s0) in
let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0)
in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem
va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 5
(va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 7 (va_get_mem va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in let (old_p1_1:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0) in let
(old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_s0) in
let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0)
in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem
va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 5
(va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 7 (va_get_mem va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack
va_s0) /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
bit_in <= 1 /\ bit_in = (if win then va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) /\
(Vale.X64.Decls.buffers_disjoint p0_b p1_b \/ p1_b == p0_b) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) p0_in p0_b 8 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) p1_in p1_b 8 (va_get_mem_layout va_s0)
Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (p0_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else
va_get_reg64 rRsi va_s0) in let (p1_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in let (old_p0_0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in let (old_p0_1:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0) in let
(old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_s0) in
let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0)
in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem
va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 5
(va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 7 (va_get_mem va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in let (old_p1_1:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0) in let
(old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_s0) in
let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0)
in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem
va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 5
(va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 7 (va_get_mem va_s0) in let p0_0 = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_sM)
in let p0_1 = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let p0_2 =
Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == (if (bit_in = 1) then
old_p1_0 else old_p0_0) /\ p0_1 == (if (bit_in = 1) then old_p1_1 else old_p0_1) /\ p0_2 == (if
(bit_in = 1) then old_p1_2 else old_p0_2) /\ p0_3 == (if (bit_in = 1) then old_p1_3 else
old_p0_3) /\ p0_4 == (if (bit_in = 1) then old_p1_4 else old_p0_4) /\ p0_5 == (if (bit_in = 1)
then old_p1_5 else old_p0_5) /\ p0_6 == (if (bit_in = 1) then old_p1_6 else old_p0_6) /\ p0_7
== (if (bit_in = 1) then old_p1_7 else old_p0_7) /\ p1_0 == (if (bit_in = 1) then old_p0_0 else
old_p1_0) /\ p1_1 == (if (bit_in = 1) then old_p0_1 else old_p1_1) /\ p1_2 == (if (bit_in = 1)
then old_p0_2 else old_p1_2) /\ p1_3 == (if (bit_in = 1) then old_p0_3 else old_p1_3) /\ p1_4
== (if (bit_in = 1) then old_p0_4 else old_p1_4) /\ p1_5 == (if (bit_in = 1) then old_p0_5 else
old_p1_5) /\ p1_6 == (if (bit_in = 1) then old_p0_6 else old_p1_6) /\ p1_7 == (if (bit_in = 1)
then old_p0_7 else old_p1_7) /\ Vale.X64.Decls.modifies_buffer_2 p0_b p1_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==>
va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64
rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM
(va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM
(va_update_reg64 rRdx va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))
[@ va_qattr]
let va_wp_Cswap2_stdcall (win:bool) (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (p0_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (p1_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let (old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0
(va_get_mem va_s0) in let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
1 (va_get_mem va_s0) in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 2 (va_get_mem va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_s0) in let
(old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in
let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0)
in let (old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem
va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0
(va_get_mem va_s0) in let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
1 (va_get_mem va_s0) in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 2 (va_get_mem va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_s0) in let
(old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in
let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0)
in let (old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem
va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ bit_in <= 1 /\
bit_in = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) /\
(Vale.X64.Decls.buffers_disjoint p0_b p1_b \/ p1_b == p0_b) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) p0_in p0_b 8 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) p1_in p1_b 8 (va_get_mem_layout va_s0)
Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8
(va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRdi va_x_rdi (va_upd_reg64 rRsi va_x_rsi
(va_upd_reg64 rRdx va_x_rdx (va_upd_mem va_x_mem va_s0)))))))))))) in va_get_ok va_sM /\ (let
(p0_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0)
(fun _ -> va_get_reg64 rRsi va_s0) in let (p1_in:(va_int_range 0 18446744073709551615)) = va_if
win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in let
(old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in
let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0)
in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem
va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3
(va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in let
(old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in
let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0)
in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem
va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3
(va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in let p0_0 =
Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_sM) in let p0_1 =
Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let p0_2 =
Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == va_if (bit_in = 1) (fun _ ->
old_p1_0) (fun _ -> old_p0_0) /\ p0_1 == va_if (bit_in = 1) (fun _ -> old_p1_1) (fun _ ->
old_p0_1) /\ p0_2 == va_if (bit_in = 1) (fun _ -> old_p1_2) (fun _ -> old_p0_2) /\ p0_3 ==
va_if (bit_in = 1) (fun _ -> old_p1_3) (fun _ -> old_p0_3) /\ p0_4 == va_if (bit_in = 1) (fun _
-> old_p1_4) (fun _ -> old_p0_4) /\ p0_5 == va_if (bit_in = 1) (fun _ -> old_p1_5) (fun _ ->
old_p0_5) /\ p0_6 == va_if (bit_in = 1) (fun _ -> old_p1_6) (fun _ -> old_p0_6) /\ p0_7 ==
va_if (bit_in = 1) (fun _ -> old_p1_7) (fun _ -> old_p0_7) /\ p1_0 == va_if (bit_in = 1) (fun _
-> old_p0_0) (fun _ -> old_p1_0) /\ p1_1 == va_if (bit_in = 1) (fun _ -> old_p0_1) (fun _ ->
old_p1_1) /\ p1_2 == va_if (bit_in = 1) (fun _ -> old_p0_2) (fun _ -> old_p1_2) /\ p1_3 ==
va_if (bit_in = 1) (fun _ -> old_p0_3) (fun _ -> old_p1_3) /\ p1_4 == va_if (bit_in = 1) (fun _
-> old_p0_4) (fun _ -> old_p1_4) /\ p1_5 == va_if (bit_in = 1) (fun _ -> old_p0_5) (fun _ ->
old_p1_5) /\ p1_6 == va_if (bit_in = 1) (fun _ -> old_p0_6) (fun _ -> old_p1_6) /\ p1_7 ==
va_if (bit_in = 1) (fun _ -> old_p0_7) (fun _ -> old_p1_7) /\ Vale.X64.Decls.modifies_buffer_2
p0_b p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==> va_k va_sM (())))
val va_wpProof_Cswap2_stdcall : win:bool -> bit_in:nat64 -> p0_b:buffer64 -> p1_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Cswap2_stdcall win bit_in p0_b p1_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Cswap2_stdcall win)
([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags;
va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRdi;
va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastUtil.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
win: Prims.bool ->
bit_in: Vale.X64.Memory.nat64 ->
p0_b: Vale.X64.Memory.buffer64 ->
p1_b: Vale.X64.Memory.buffer64
-> Vale.X64.QuickCode.va_quickCode Prims.unit
(Vale.Curve25519.X64.FastUtil.va_code_Cswap2_stdcall win) | Prims.Tot | [
"total"
] | [] | [
"Prims.bool",
"Vale.X64.Memory.nat64",
"Vale.X64.Memory.buffer64",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.Curve25519.X64.FastUtil.va_code_Cswap2_stdcall",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_stackTaint",
"Vale.X64.QuickCode.va_Mod_stack",
"Vale.X64.QuickCode.va_Mod_mem_layout",
"Vale.X64.QuickCode.va_Mod_mem_heaplet",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_Mod_reg64",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Machine_s.rRdi",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.QuickCode.va_Mod_mem",
"Prims.Nil",
"Vale.Curve25519.X64.FastUtil.va_wp_Cswap2_stdcall",
"Vale.Curve25519.X64.FastUtil.va_wpProof_Cswap2_stdcall",
"Vale.X64.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Cswap2_stdcall (win: bool) (bit_in: nat64) (p0_b p1_b: buffer64)
: (va_quickCode unit (va_code_Cswap2_stdcall win)) =
| (va_QProc (va_code_Cswap2_stdcall win)
([
va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags;
va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRdi;
va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_mem
])
(va_wp_Cswap2_stdcall win bit_in p0_b p1_b)
(va_wpProof_Cswap2_stdcall win bit_in p0_b p1_b)) | false |
Pulse.Lib.Mutex.fst | Pulse.Lib.Mutex.new_mutex | val new_mutex (#a:Type0) (p:a -> vprop) (x:a)
: stt (mutex p)
(requires p x)
(ensures fun _ -> emp) | val new_mutex (#a:Type0) (p:a -> vprop) (x:a)
: stt (mutex p)
(requires p x)
(ensures fun _ -> emp) | let new_mutex = new_mutex' | {
"file_name": "share/steel/examples/pulse/lib/Pulse.Lib.Mutex.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 26,
"end_line": 46,
"start_col": 0,
"start_line": 46
} | (*
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.Mutex
open Pulse.Lib.Core
open Pulse.Lib.Reference
open Pulse.Lib.SpinLock
module B = Pulse.Lib.Box
open Pulse.Main
noeq
type mutex (#a:Type0) (p:a -> vprop) : Type0 = {
r:B.box a;
l:lock (exists* v. B.pts_to r v ** p v)
}
```pulse
fn new_mutex' (#a:Type0) (p:a -> vprop) (x:a)
requires p x
returns m:mutex p
ensures emp
{
let r = B.alloc x;
let l = new_lock (exists* v. B.pts_to r v ** p v);
let m = {r; l};
m
}
``` | {
"checked_file": "/",
"dependencies": [
"Pulse.Main.fsti.checked",
"Pulse.Lib.SpinLock.fsti.checked",
"Pulse.Lib.Reference.fsti.checked",
"Pulse.Lib.Core.fsti.checked",
"Pulse.Lib.Box.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Pulse.Lib.Mutex.fst"
} | [
{
"abbrev": false,
"full_module": "Pulse.Main",
"short_module": null
},
{
"abbrev": true,
"full_module": "Pulse.Lib.Box",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Pulse.Lib.SpinLock",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Core",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Core",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib",
"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: (_: a -> Pulse.Lib.Core.vprop) -> x: a
-> Pulse.Lib.Core.stt (Pulse.Lib.Mutex.mutex p) (p x) (fun _ -> Pulse.Lib.Core.emp) | Prims.Tot | [
"total"
] | [] | [
"Pulse.Lib.Mutex.new_mutex'"
] | [] | false | false | false | false | false | let new_mutex =
| new_mutex' | false |
Vale.Curve25519.X64.FastUtil.fsti | Vale.Curve25519.X64.FastUtil.va_req_Cswap2_stdcall | val va_req_Cswap2_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(bit_in: nat64)
(p0_b p1_b: buffer64)
: prop | val va_req_Cswap2_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(bit_in: nat64)
(p0_b p1_b: buffer64)
: prop | let va_req_Cswap2_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (bit_in:nat64)
(p0_b:buffer64) (p1_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Cswap2_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(p0_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else
va_get_reg64 rRsi va_s0) in let (p1_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in let (old_p0_0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in let (old_p0_1:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0) in let
(old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_s0) in
let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0)
in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem
va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 5
(va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 7 (va_get_mem va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in let (old_p1_1:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0) in let
(old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_s0) in
let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0)
in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem
va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 5
(va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 7 (va_get_mem va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack
va_s0) /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
bit_in <= 1 /\ bit_in = (if win then va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) /\
(Vale.X64.Decls.buffers_disjoint p0_b p1_b \/ p1_b == p0_b) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) p0_in p0_b 8 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) p1_in p1_b 8 (va_get_mem_layout va_s0)
Secret)) | {
"file_name": "obj/Vale.Curve25519.X64.FastUtil.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 12,
"end_line": 598,
"start_col": 0,
"start_line": 569
} | module Vale.Curve25519.X64.FastUtil
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Fast_add1
val va_code_Fast_add1 : va_dummy:unit -> Tot va_code
val va_codegen_success_Fast_add1 : va_dummy:unit -> Tot va_pbool
let va_req_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
: prop =
(va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0))
let va_ens_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1 va_b0 va_s0 dst_b inA_b inB /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fast_add1 : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
adx_enabled /\ bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0)
(va_get_mem va_s0) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rdx:nat64) (va_x_r8:nat64)
(va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64) (va_x_heap0:vale_heap)
(va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11
va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8
(va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) ==> va_k va_sM (())))
val va_wpProof_Fast_add1 : dst_b:buffer64 -> inA_b:buffer64 -> inB:nat64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_add1 dst_b inA_b inB va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_add1 ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) : (va_quickCode unit
(va_code_Fast_add1 ())) =
(va_QProc (va_code_Fast_add1 ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx;
va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fast_add1 dst_b inA_b inB) (va_wpProof_Fast_add1 dst_b
inA_b inB))
//--
//-- Fast_add1_stdcall
val va_code_Fast_add1_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fast_add1_stdcall : win:bool -> Tot va_pbool
let va_req_Fast_add1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) : prop =
(va_require_total va_b0 (va_code_Fast_add1_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret))
let va_ens_Fast_add1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1_stdcall va_b0 va_s0 win dst_b inA_b inB_in /\ va_ensure_total va_b0 va_s0 va_sM
va_fM /\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fast_add1_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_in:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_add1_stdcall win) va_s0 /\ va_get_ok va_s0 /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let a0 = Vale.X64.Decls.buffer64_read
inA_b 0 (va_get_mem va_s0) in let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0)
in let a2 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fast_add1_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_in:nat64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in =
va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rbx:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64) (va_x_rbp:nat64)
(va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64)
(va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let a0 =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) ==> va_k va_sM (())))
val va_wpProof_Fast_add1_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_in:nat64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_add1_stdcall win dst_b inA_b inB_in va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_add1_stdcall win)
([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags;
va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10;
va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi;
va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax;
va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_add1_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_in:nat64) :
(va_quickCode unit (va_code_Fast_add1_stdcall win)) =
(va_QProc (va_code_Fast_add1_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fast_add1_stdcall win dst_b inA_b
inB_in) (va_wpProof_Fast_add1_stdcall win dst_b inA_b inB_in))
//--
//-- Cswap2
val va_code_Cswap2 : va_dummy:unit -> Tot va_code
val va_codegen_success_Cswap2 : va_dummy:unit -> Tot va_pbool
let va_req_Cswap2 (va_b0:va_code) (va_s0:va_state) (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64) :
prop =
(va_require_total va_b0 (va_code_Cswap2 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in
let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0)
in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem
va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3
(va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in let
(old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in
let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0)
in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem
va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3
(va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ bit_in == va_get_reg64 rRdi va_s0 /\
va_get_reg64 rRdi va_s0 <= 1 /\ (Vale.X64.Decls.buffers_disjoint p1_b p0_b \/ p1_b == p0_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRsi va_s0) p0_b 8
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdx va_s0) p1_b 8 (va_get_mem_layout va_s0) Secret))
let va_ens_Cswap2 (va_b0:va_code) (va_s0:va_state) (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Cswap2 va_b0 va_s0 bit_in p0_b p1_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0
(va_get_mem va_s0) in let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
1 (va_get_mem va_s0) in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 2 (va_get_mem va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_s0) in let
(old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in
let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0)
in let (old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem
va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0
(va_get_mem va_s0) in let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
1 (va_get_mem va_s0) in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 2 (va_get_mem va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_s0) in let
(old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in
let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0)
in let (old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem
va_s0) in Vale.X64.Decls.modifies_buffer_2 p0_b p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\
(let p0_0 = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_sM) in let p0_1 =
Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let p0_2 =
Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == (if (va_get_reg64 rRdi va_s0
= 1) then old_p1_0 else old_p0_0) /\ p0_1 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_1
else old_p0_1) /\ p0_2 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_2 else old_p0_2) /\
p0_3 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_3 else old_p0_3) /\ p0_4 == (if
(va_get_reg64 rRdi va_s0 = 1) then old_p1_4 else old_p0_4) /\ p0_5 == (if (va_get_reg64 rRdi
va_s0 = 1) then old_p1_5 else old_p0_5) /\ p0_6 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p1_6 else old_p0_6) /\ p0_7 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_7 else
old_p0_7) /\ p1_0 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_0 else old_p1_0) /\ p1_1 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_1 else old_p1_1) /\ p1_2 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_2 else old_p1_2) /\ p1_3 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p0_3 else old_p1_3) /\ p1_4 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_4 else
old_p1_4) /\ p1_5 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_5 else old_p1_5) /\ p1_6 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_6 else old_p1_6) /\ p1_7 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_7 else old_p1_7))) /\ va_state_eq va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdi va_sM (va_update_ok
va_sM (va_update_mem va_sM va_s0))))))))))
val va_lemma_Cswap2 : va_b0:va_code -> va_s0:va_state -> bit_in:nat64 -> p0_b:buffer64 ->
p1_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Cswap2 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in
let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0)
in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem
va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3
(va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in let
(old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in
let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0)
in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem
va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3
(va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ bit_in == va_get_reg64 rRdi va_s0 /\
va_get_reg64 rRdi va_s0 <= 1 /\ (Vale.X64.Decls.buffers_disjoint p1_b p0_b \/ p1_b == p0_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRsi va_s0) p0_b 8
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdx va_s0) p1_b 8 (va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0)
in let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem
va_s0) in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2
(va_get_mem va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
3 (va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let
(old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in
let (old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0)
in let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem
va_s0) in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2
(va_get_mem va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
3 (va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let
(old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in
Vale.X64.Decls.modifies_buffer_2 p0_b p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (let p0_0 =
Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_sM) in let p0_1 =
Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let p0_2 =
Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == (if (va_get_reg64 rRdi va_s0
= 1) then old_p1_0 else old_p0_0) /\ p0_1 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_1
else old_p0_1) /\ p0_2 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_2 else old_p0_2) /\
p0_3 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_3 else old_p0_3) /\ p0_4 == (if
(va_get_reg64 rRdi va_s0 = 1) then old_p1_4 else old_p0_4) /\ p0_5 == (if (va_get_reg64 rRdi
va_s0 = 1) then old_p1_5 else old_p0_5) /\ p0_6 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p1_6 else old_p0_6) /\ p0_7 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_7 else
old_p0_7) /\ p1_0 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_0 else old_p1_0) /\ p1_1 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_1 else old_p1_1) /\ p1_2 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_2 else old_p1_2) /\ p1_3 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p0_3 else old_p1_3) /\ p1_4 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_4 else
old_p1_4) /\ p1_5 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_5 else old_p1_5) /\ p1_6 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_6 else old_p1_6) /\ p1_7 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_7 else old_p1_7))) /\ va_state_eq va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdi va_sM (va_update_ok
va_sM (va_update_mem va_sM va_s0)))))))))))
[@ va_qattr]
let va_wp_Cswap2 (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0
(va_get_mem va_s0) in let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
1 (va_get_mem va_s0) in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 2 (va_get_mem va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_s0) in let
(old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in
let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0)
in let (old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem
va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0
(va_get_mem va_s0) in let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
1 (va_get_mem va_s0) in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 2 (va_get_mem va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_s0) in let
(old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in
let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0)
in let (old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem
va_s0) in Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
bit_in == va_get_reg64 rRdi va_s0 /\ va_get_reg64 rRdi va_s0 <= 1 /\
(Vale.X64.Decls.buffers_disjoint p1_b p0_b \/ p1_b == p0_b) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) p0_b 8 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) p1_b 8
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rdi:nat64)
(va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) . let va_sM = va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags va_x_efl (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdi va_x_rdi
(va_upd_mem va_x_mem va_s0))))))) in va_get_ok va_sM /\ (let (old_p0_0:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in let
(old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0) in
let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_s0)
in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem
va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 4
(va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in let
(old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0) in
let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_s0)
in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem
va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 4
(va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in Vale.X64.Decls.modifies_buffer_2 p0_b
p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (let p0_0 = Vale.X64.Decls.buffer64_read p0_b 0
(va_get_mem va_sM) in let p0_1 = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let
p0_2 = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == va_if (va_get_reg64 rRdi
va_s0 = 1) (fun _ -> old_p1_0) (fun _ -> old_p0_0) /\ p0_1 == va_if (va_get_reg64 rRdi va_s0 =
1) (fun _ -> old_p1_1) (fun _ -> old_p0_1) /\ p0_2 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun
_ -> old_p1_2) (fun _ -> old_p0_2) /\ p0_3 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_3) (fun _ -> old_p0_3) /\ p0_4 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_4) (fun _ -> old_p0_4) /\ p0_5 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_5) (fun _ -> old_p0_5) /\ p0_6 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_6) (fun _ -> old_p0_6) /\ p0_7 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_7) (fun _ -> old_p0_7) /\ p1_0 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_0) (fun _ -> old_p1_0) /\ p1_1 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_1) (fun _ -> old_p1_1) /\ p1_2 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_2) (fun _ -> old_p1_2) /\ p1_3 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_3) (fun _ -> old_p1_3) /\ p1_4 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_4) (fun _ -> old_p1_4) /\ p1_5 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_5) (fun _ -> old_p1_5) /\ p1_6 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_6) (fun _ -> old_p1_6) /\ p1_7 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_7) (fun _ -> old_p1_7))) ==> va_k va_sM (())))
val va_wpProof_Cswap2 : bit_in:nat64 -> p0_b:buffer64 -> p1_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Cswap2 bit_in p0_b p1_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Cswap2 ()) ([va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdi; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Cswap2 (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64) : (va_quickCode unit
(va_code_Cswap2 ())) =
(va_QProc (va_code_Cswap2 ()) ([va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags;
va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdi; va_Mod_mem])
(va_wp_Cswap2 bit_in p0_b p1_b) (va_wpProof_Cswap2 bit_in p0_b p1_b))
//--
//-- Cswap2_stdcall
val va_code_Cswap2_stdcall : win:bool -> Tot va_code | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastUtil.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
win: Prims.bool ->
bit_in: Vale.X64.Memory.nat64 ->
p0_b: Vale.X64.Memory.buffer64 ->
p1_b: Vale.X64.Memory.buffer64
-> Prims.prop | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Prims.bool",
"Vale.X64.Memory.nat64",
"Vale.X64.Memory.buffer64",
"Prims.l_and",
"Vale.X64.Decls.va_require_total",
"Vale.Curve25519.X64.FastUtil.va_code_Cswap2_stdcall",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.eq2",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Stack_i.init_rsp",
"Vale.X64.Decls.va_get_stack",
"Vale.X64.Memory.is_initial_heap",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Decls.va_get_mem",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRdi",
"Prims.l_or",
"Vale.X64.Decls.buffers_disjoint",
"Vale.X64.Decls.validDstAddrs64",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.buffer64_read",
"Vale.X64.Decls.va_int_range",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRsi",
"Prims.prop"
] | [] | false | false | false | true | true | let va_req_Cswap2_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(bit_in: nat64)
(p0_b p1_b: buffer64)
: prop =
| (va_require_total va_b0 (va_code_Cswap2_stdcall win) va_s0 /\ va_get_ok va_s0 /\
(let p0_in:(va_int_range 0 18446744073709551615) =
(if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0)
in
let p1_in:(va_int_range 0 18446744073709551615) =
(if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0)
in
let old_p0_0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in
let old_p0_1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0) in
let old_p0_2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_s0) in
let old_p0_3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0) in
let old_p0_4:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_s0) in
let old_p0_5:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in
let old_p0_6:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in
let old_p0_7:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in
let old_p1_0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in
let old_p1_1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0) in
let old_p1_2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_s0) in
let old_p1_3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0) in
let old_p1_4:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_s0) in
let old_p1_5:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in
let old_p1_6:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in
let old_p1_7:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ bit_in <= 1 /\
bit_in = (if win then va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) /\
(Vale.X64.Decls.buffers_disjoint p0_b p1_b \/ p1_b == p0_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) p0_in p0_b 8 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) p1_in p1_b 8 (va_get_mem_layout va_s0) Secret)
) | false |
Vale.AES.GCTR_s.fst | Vale.AES.GCTR_s.gctr_encrypt_LE_reveal | val gctr_encrypt_LE_reveal : _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures Vale.AES.GCTR_s.gctr_encrypt_LE == Vale.AES.GCTR_s.gctr_encrypt_LE_def) | let gctr_encrypt_LE_reveal = opaque_revealer (`%gctr_encrypt_LE) gctr_encrypt_LE gctr_encrypt_LE_def | {
"file_name": "vale/specs/crypto/Vale.AES.GCTR_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 112,
"end_line": 71,
"start_col": 12,
"start_line": 71
} | module Vale.AES.GCTR_s
// IMPORTANT: Following NIST's specification, this spec is written assuming a big-endian mapping from bytes to quad32s
// Since the AES spec (AES_s) is in little-endian, we need to byteswap each time we call AES
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
open Vale.AES.AES_s
open FStar.Seq
// The max length of pow2_32 corresponds to the max length of buffers in Low*
// length plain < pow2_32 <= spec max of 2**39 - 256;
let is_gctr_plain_LE (p:seq nat8) : prop0 = length p < pow2_32
type gctr_plain_LE:eqtype = p:seq nat8 { is_gctr_plain_LE p }
type gctr_plain_internal_LE:eqtype = seq quad32
let inc32 (cb:quad32) (i:int) : quad32 =
Mkfour ((cb.lo0 + i) % pow2_32) cb.lo1 cb.hi2 cb.hi3
let gctr_encrypt_block (icb_BE:quad32) (plain_LE:quad32) (alg:algorithm) (key:seq nat32) (i:int) : Pure quad32
(requires is_aes_key_LE alg key)
(ensures fun _ -> True)
=
let icb_LE = reverse_bytes_quad32 (inc32 icb_BE i) in
quad32_xor plain_LE (aes_encrypt_LE alg key icb_LE)
let rec gctr_encrypt_recursive (icb_BE:quad32) (plain:gctr_plain_internal_LE)
(alg:algorithm) (key:aes_key_LE alg) (i:int) : Tot (seq quad32) (decreases %[length plain]) =
if length plain = 0 then empty
else
cons (gctr_encrypt_block icb_BE (head plain) alg key i) (gctr_encrypt_recursive icb_BE (tail plain) alg key (i + 1))
let pad_to_128_bits (p:seq nat8) : Pure (seq nat8)
(requires True)
(ensures fun q -> length q % 16 == 0 /\ length q <= length p + 15)
=
let num_extra_bytes = length p % 16 in
if num_extra_bytes = 0 then p
else p @| (create (16 - num_extra_bytes) 0)
// little-endian, except for icb_BE
let gctr_encrypt_LE_def (icb_BE:quad32) (plain:seq nat8) (alg:algorithm) (key:seq nat32) : Pure (seq nat8)
(requires is_gctr_plain_LE plain /\ is_aes_key_LE alg key)
(ensures fun _ -> True)
=
let num_extra = (length plain) % 16 in
if num_extra = 0 then
let plain_quads_LE = le_bytes_to_seq_quad32 plain in
let cipher_quads_LE = gctr_encrypt_recursive icb_BE plain_quads_LE alg key 0 in
le_seq_quad32_to_bytes cipher_quads_LE
else
let full_bytes_len = (length plain) - num_extra in
let full_blocks, final_block = split plain full_bytes_len in
let full_quads_LE = le_bytes_to_seq_quad32 full_blocks in
let final_quad_LE = le_bytes_to_quad32 (pad_to_128_bits final_block) in
let cipher_quads_LE = gctr_encrypt_recursive icb_BE full_quads_LE alg key 0 in
let final_cipher_quad_LE = gctr_encrypt_block icb_BE final_quad_LE alg key (full_bytes_len / 16) in
let cipher_bytes_full_LE = le_seq_quad32_to_bytes cipher_quads_LE in
let final_cipher_bytes_LE = slice (le_quad32_to_bytes final_cipher_quad_LE) 0 num_extra in
cipher_bytes_full_LE @| final_cipher_bytes_LE | {
"checked_file": "/",
"dependencies": [
"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.AES.AES_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.GCTR_s.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures Vale.AES.GCTR_s.gctr_encrypt_LE == Vale.AES.GCTR_s.gctr_encrypt_LE_def) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Opaque_s.opaque_revealer",
"Vale.Def.Types_s.quad32",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat8",
"Vale.AES.AES_common_s.algorithm",
"Vale.Def.Types_s.nat32",
"Prims.l_and",
"Vale.AES.GCTR_s.is_gctr_plain_LE",
"Vale.AES.AES_s.is_aes_key_LE",
"Prims.l_True",
"Vale.AES.GCTR_s.gctr_encrypt_LE",
"Vale.AES.GCTR_s.gctr_encrypt_LE_def"
] | [] | true | false | true | false | false | let gctr_encrypt_LE_reveal =
| opaque_revealer (`%gctr_encrypt_LE) gctr_encrypt_LE gctr_encrypt_LE_def | false |
|
SteelTableJoin.fst | SteelTableJoin.v3' | val v3' (#p: Ghost.erased nat) (al err: ptr)
: STT unit
((pts_to1 al p) `star` (pts_to1 err 0))
(fun _ -> exists_ (fun p -> exists_ (fun v -> (pts_to1 al p) `star` (pts_to1 err v)))) | val v3' (#p: Ghost.erased nat) (al err: ptr)
: STT unit
((pts_to1 al p) `star` (pts_to1 err 0))
(fun _ -> exists_ (fun p -> exists_ (fun v -> (pts_to1 al p) `star` (pts_to1 err v)))) | let v3' (#p: Ghost.erased nat) (al: ptr) (err: ptr) : STT unit
(pts_to1 al p `star` pts_to1 err 0)
(fun _ -> exists_ (fun p -> exists_ (fun v -> pts_to1 al p `star` pts_to1 err v)))
= let ar = split al in
let _ = gen_elim () in
let _ = v1 ar err in
let _ = gen_elim () in
let _ = join al ar in
noop () | {
"file_name": "share/steel/tests/SteelTableJoin.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 9,
"end_line": 74,
"start_col": 0,
"start_line": 66
} | module SteelTableJoin
open Steel.ST.GenElim
assume
val ptr : Type0
assume
val pts_to1 (p: ptr) (v: Ghost.erased nat) : vprop
assume
val split
(#v: Ghost.erased nat)
(p: ptr)
: STT ptr
(pts_to1 p v)
(fun res -> exists_ (fun vl -> exists_ (fun vr -> pts_to1 p vl `star` pts_to1 res vr)))
assume val join (#opened: _) (#pl #pr: Ghost.erased nat) (al ar: ptr) : STGhostT (Ghost.erased nat) opened (pts_to1 al pl `star` pts_to1 ar pr) (fun res -> pts_to1 al res)
assume val v1 (#p: Ghost.erased nat) (a: ptr) (err: ptr) : STT unit
(pts_to1 a p `star` pts_to1 err 0)
(fun _ -> pts_to1 a p `star` exists_ (fun v -> pts_to1 err v))
let v2 (#p: Ghost.erased nat) (al: ptr) (err: ptr) : STT unit
(pts_to1 al p `star` pts_to1 err 0)
(fun _ -> exists_ (fun p -> exists_ (fun v -> pts_to1 al p `star` pts_to1 err v)))
= let ar = split al in
let _ = gen_elim () in
let _ = v1 ar err in
let _ = gen_elim () in
let _ = join al ar in
intro_exists _ (fun v -> pts_to1 al _ `star` pts_to1 err v);
intro_exists _ (fun p -> exists_ (fun v -> pts_to1 al p `star` pts_to1 err v));
return ()
let v2' (#p: Ghost.erased nat) (al: ptr) (err: ptr) : STT unit
(pts_to1 al p `star` pts_to1 err 0)
(fun _ -> exists_ (fun p -> exists_ (fun v -> pts_to1 al p `star` pts_to1 err v)))
= let ar = split al in
let _ = gen_elim () in
let _ = v1 ar err in
let _ = elim_exists () in
// let _ = elim_pure _ in
let _ = noop () in
let _ = join al ar in
return ()
#set-options "--print_implicits"
assume val noop_f (#opened: _) (#p: vprop) (_: unit) : STGhostF unit opened p (fun _ -> p) True (fun _ -> True)
#set-options "--print_full_names"
let v3 (#pl #pr: Ghost.erased nat) (al: ptr) (ar: ptr) (err: ptr) : STT unit
(pts_to1 al pl `star` pts_to1 ar pr `star` exists_ (fun v -> pts_to1 err v))
(fun _ -> exists_ (fun p -> exists_ (fun v -> pts_to1 al p `star` pts_to1 err v)))
= let _ = gen_elim () in
let _ = join al ar in
// let _ = gen_elim () in
// assert_ (exists_ (fun p -> exists_ (fun v -> pts_to1 al p `star` pts_to1 err v)));
noop () | {
"checked_file": "/",
"dependencies": [
"Steel.ST.GenElim.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "SteelTableJoin.fst"
} | [
{
"abbrev": false,
"full_module": "Steel.ST.GenElim",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | al: SteelTableJoin.ptr -> err: SteelTableJoin.ptr -> Steel.ST.Effect.STT Prims.unit | Steel.ST.Effect.STT | [] | [] | [
"FStar.Ghost.erased",
"Prims.nat",
"SteelTableJoin.ptr",
"Steel.ST.Util.noop",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Prims.unit",
"SteelTableJoin.join",
"Steel.ST.GenElim.Base.fstp",
"FStar.Ghost.reveal",
"FStar.Pervasives.Native.tuple2",
"Steel.ST.GenElim.Base.sndp",
"Steel.ST.GenElim.gen_elim",
"Steel.Effect.Common.VStar",
"SteelTableJoin.pts_to1",
"Steel.ST.Util.exists_",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.star",
"Prims.l_and",
"Prims.l_True",
"Prims.prop",
"SteelTableJoin.v1",
"SteelTableJoin.split"
] | [] | false | true | false | false | false | let v3' (#p: Ghost.erased nat) (al err: ptr)
: STT unit
((pts_to1 al p) `star` (pts_to1 err 0))
(fun _ -> exists_ (fun p -> exists_ (fun v -> (pts_to1 al p) `star` (pts_to1 err v)))) =
| let ar = split al in
let _ = gen_elim () in
let _ = v1 ar err in
let _ = gen_elim () in
let _ = join al ar in
noop () | false |
Pulse.Lib.Mutex.fst | Pulse.Lib.Mutex.belongs_to_mutex | val belongs_to_mutex (#a:Type0) (#p:a -> vprop) (r:ref a) (m:mutex p) : vprop | val belongs_to_mutex (#a:Type0) (#p:a -> vprop) (r:ref a) (m:mutex p) : vprop | let belongs_to_mutex (#a:Type0) (#p:a -> vprop) (r:ref a) (m:mutex p) : vprop =
pure (r == B.box_to_ref m.r) | {
"file_name": "share/steel/examples/pulse/lib/Pulse.Lib.Mutex.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 30,
"end_line": 49,
"start_col": 0,
"start_line": 48
} | (*
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.Mutex
open Pulse.Lib.Core
open Pulse.Lib.Reference
open Pulse.Lib.SpinLock
module B = Pulse.Lib.Box
open Pulse.Main
noeq
type mutex (#a:Type0) (p:a -> vprop) : Type0 = {
r:B.box a;
l:lock (exists* v. B.pts_to r v ** p v)
}
```pulse
fn new_mutex' (#a:Type0) (p:a -> vprop) (x:a)
requires p x
returns m:mutex p
ensures emp
{
let r = B.alloc x;
let l = new_lock (exists* v. B.pts_to r v ** p v);
let m = {r; l};
m
}
```
let new_mutex = new_mutex' | {
"checked_file": "/",
"dependencies": [
"Pulse.Main.fsti.checked",
"Pulse.Lib.SpinLock.fsti.checked",
"Pulse.Lib.Reference.fsti.checked",
"Pulse.Lib.Core.fsti.checked",
"Pulse.Lib.Box.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Pulse.Lib.Mutex.fst"
} | [
{
"abbrev": false,
"full_module": "Pulse.Main",
"short_module": null
},
{
"abbrev": true,
"full_module": "Pulse.Lib.Box",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Pulse.Lib.SpinLock",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Core",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Core",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib",
"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 a -> m: Pulse.Lib.Mutex.mutex p -> Pulse.Lib.Core.vprop | Prims.Tot | [
"total"
] | [] | [
"Pulse.Lib.Core.vprop",
"Pulse.Lib.Reference.ref",
"Pulse.Lib.Mutex.mutex",
"Pulse.Lib.Core.pure",
"Prims.eq2",
"Pulse.Lib.Box.box_to_ref",
"Pulse.Lib.Mutex.__proj__Mkmutex__item__r"
] | [] | false | false | false | false | false | let belongs_to_mutex (#a: Type0) (#p: (a -> vprop)) (r: ref a) (m: mutex p) : vprop =
| pure (r == B.box_to_ref m.r) | false |
Pulse.Lib.Mutex.fst | Pulse.Lib.Mutex.lock | val lock (#a:Type0) (#p:a -> vprop) (m:mutex p)
: stt (ref a)
(requires emp)
(ensures fun r -> r `belongs_to_mutex` m ** (exists* v. pts_to r v ** p v)) | val lock (#a:Type0) (#p:a -> vprop) (m:mutex p)
: stt (ref a)
(requires emp)
(ensures fun r -> r `belongs_to_mutex` m ** (exists* v. pts_to r v ** p v)) | let lock = lock' | {
"file_name": "share/steel/examples/pulse/lib/Pulse.Lib.Mutex.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 16,
"end_line": 64,
"start_col": 0,
"start_line": 64
} | (*
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.Mutex
open Pulse.Lib.Core
open Pulse.Lib.Reference
open Pulse.Lib.SpinLock
module B = Pulse.Lib.Box
open Pulse.Main
noeq
type mutex (#a:Type0) (p:a -> vprop) : Type0 = {
r:B.box a;
l:lock (exists* v. B.pts_to r v ** p v)
}
```pulse
fn new_mutex' (#a:Type0) (p:a -> vprop) (x:a)
requires p x
returns m:mutex p
ensures emp
{
let r = B.alloc x;
let l = new_lock (exists* v. B.pts_to r v ** p v);
let m = {r; l};
m
}
```
let new_mutex = new_mutex'
let belongs_to_mutex (#a:Type0) (#p:a -> vprop) (r:ref a) (m:mutex p) : vprop =
pure (r == B.box_to_ref m.r)
```pulse
fn lock' (#a:Type0) (#p:a -> vprop) (m:mutex p)
requires emp
returns r:ref a
ensures r `belongs_to_mutex` m ** (exists* v. pts_to r v ** p v)
{
acquire m.l;
B.to_ref_pts_to m.r;
fold (belongs_to_mutex (B.box_to_ref m.r) m);
B.box_to_ref m.r
}
``` | {
"checked_file": "/",
"dependencies": [
"Pulse.Main.fsti.checked",
"Pulse.Lib.SpinLock.fsti.checked",
"Pulse.Lib.Reference.fsti.checked",
"Pulse.Lib.Core.fsti.checked",
"Pulse.Lib.Box.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Pulse.Lib.Mutex.fst"
} | [
{
"abbrev": false,
"full_module": "Pulse.Main",
"short_module": null
},
{
"abbrev": true,
"full_module": "Pulse.Lib.Box",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Pulse.Lib.SpinLock",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Core",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Core",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib",
"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 | m: Pulse.Lib.Mutex.mutex p
-> Pulse.Lib.Core.stt (Pulse.Lib.Reference.ref a)
Pulse.Lib.Core.emp
(fun r ->
Pulse.Lib.Mutex.belongs_to_mutex r m **
(exists* (v: a). Pulse.Lib.Reference.pts_to r v ** p v)) | Prims.Tot | [
"total"
] | [] | [
"Pulse.Lib.Mutex.lock'"
] | [] | false | false | false | false | false | let lock =
| lock' | false |
Pulse.Lib.Mutex.fst | Pulse.Lib.Mutex.unlock | val unlock (#a:Type0) (#p:a -> vprop) (m:mutex p) (r:ref a)
: stt unit
(requires r `belongs_to_mutex` m ** (exists* v. pts_to r v ** p v))
(ensures fun _ -> emp) | val unlock (#a:Type0) (#p:a -> vprop) (m:mutex p) (r:ref a)
: stt unit
(requires r `belongs_to_mutex` m ** (exists* v. pts_to r v ** p v))
(ensures fun _ -> emp) | let unlock = unlock' | {
"file_name": "share/steel/examples/pulse/lib/Pulse.Lib.Mutex.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 20,
"end_line": 78,
"start_col": 0,
"start_line": 78
} | (*
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.Mutex
open Pulse.Lib.Core
open Pulse.Lib.Reference
open Pulse.Lib.SpinLock
module B = Pulse.Lib.Box
open Pulse.Main
noeq
type mutex (#a:Type0) (p:a -> vprop) : Type0 = {
r:B.box a;
l:lock (exists* v. B.pts_to r v ** p v)
}
```pulse
fn new_mutex' (#a:Type0) (p:a -> vprop) (x:a)
requires p x
returns m:mutex p
ensures emp
{
let r = B.alloc x;
let l = new_lock (exists* v. B.pts_to r v ** p v);
let m = {r; l};
m
}
```
let new_mutex = new_mutex'
let belongs_to_mutex (#a:Type0) (#p:a -> vprop) (r:ref a) (m:mutex p) : vprop =
pure (r == B.box_to_ref m.r)
```pulse
fn lock' (#a:Type0) (#p:a -> vprop) (m:mutex p)
requires emp
returns r:ref a
ensures r `belongs_to_mutex` m ** (exists* v. pts_to r v ** p v)
{
acquire m.l;
B.to_ref_pts_to m.r;
fold (belongs_to_mutex (B.box_to_ref m.r) m);
B.box_to_ref m.r
}
```
let lock = lock'
```pulse
fn unlock' (#a:Type0) (#p:a -> vprop) (m:mutex p) (r:ref a)
requires r `belongs_to_mutex` m ** (exists* v. pts_to r v ** p v)
ensures emp
{
unfold (belongs_to_mutex r m);
with v. rewrite (pts_to r v) as (pts_to (B.box_to_ref m.r) v);
B.to_box_pts_to m.r;
release m.l;
}
``` | {
"checked_file": "/",
"dependencies": [
"Pulse.Main.fsti.checked",
"Pulse.Lib.SpinLock.fsti.checked",
"Pulse.Lib.Reference.fsti.checked",
"Pulse.Lib.Core.fsti.checked",
"Pulse.Lib.Box.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Pulse.Lib.Mutex.fst"
} | [
{
"abbrev": false,
"full_module": "Pulse.Main",
"short_module": null
},
{
"abbrev": true,
"full_module": "Pulse.Lib.Box",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Pulse.Lib.SpinLock",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Core",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Core",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib",
"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 | m: Pulse.Lib.Mutex.mutex p -> r: Pulse.Lib.Reference.ref a
-> Pulse.Lib.Core.stt Prims.unit
(Pulse.Lib.Mutex.belongs_to_mutex r m **
(exists* (v: a). Pulse.Lib.Reference.pts_to r v ** p v))
(fun _ -> Pulse.Lib.Core.emp) | Prims.Tot | [
"total"
] | [] | [
"Pulse.Lib.Mutex.unlock'"
] | [] | false | false | false | false | false | let unlock =
| unlock' | false |
Vale.AES.GCTR_s.fst | Vale.AES.GCTR_s.inc32 | val inc32 (cb: quad32) (i: int) : quad32 | val inc32 (cb: quad32) (i: int) : quad32 | let inc32 (cb:quad32) (i:int) : quad32 =
Mkfour ((cb.lo0 + i) % pow2_32) cb.lo1 cb.hi2 cb.hi3 | {
"file_name": "vale/specs/crypto/Vale.AES.GCTR_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 54,
"end_line": 21,
"start_col": 0,
"start_line": 20
} | module Vale.AES.GCTR_s
// IMPORTANT: Following NIST's specification, this spec is written assuming a big-endian mapping from bytes to quad32s
// Since the AES spec (AES_s) is in little-endian, we need to byteswap each time we call AES
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
open Vale.AES.AES_s
open FStar.Seq
// The max length of pow2_32 corresponds to the max length of buffers in Low*
// length plain < pow2_32 <= spec max of 2**39 - 256;
let is_gctr_plain_LE (p:seq nat8) : prop0 = length p < pow2_32
type gctr_plain_LE:eqtype = p:seq nat8 { is_gctr_plain_LE p }
type gctr_plain_internal_LE:eqtype = seq quad32 | {
"checked_file": "/",
"dependencies": [
"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.AES.AES_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.GCTR_s.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | cb: Vale.Def.Types_s.quad32 -> i: Prims.int -> Vale.Def.Types_s.quad32 | Prims.Tot | [
"total"
] | [] | [
"Vale.Def.Types_s.quad32",
"Prims.int",
"Vale.Def.Words_s.Mkfour",
"Vale.Def.Types_s.nat32",
"Prims.op_Modulus",
"Prims.op_Addition",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Vale.Def.Words_s.pow2_32",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3"
] | [] | false | false | false | true | false | let inc32 (cb: quad32) (i: int) : quad32 =
| Mkfour ((cb.lo0 + i) % pow2_32) cb.lo1 cb.hi2 cb.hi3 | false |
Vale.AES.GCTR_s.fst | Vale.AES.GCTR_s.pad_to_128_bits | val pad_to_128_bits (p: seq nat8)
: Pure (seq nat8)
(requires True)
(ensures fun q -> length q % 16 == 0 /\ length q <= length p + 15) | val pad_to_128_bits (p: seq nat8)
: Pure (seq nat8)
(requires True)
(ensures fun q -> length q % 16 == 0 /\ length q <= length p + 15) | let pad_to_128_bits (p:seq nat8) : Pure (seq nat8)
(requires True)
(ensures fun q -> length q % 16 == 0 /\ length q <= length p + 15)
=
let num_extra_bytes = length p % 16 in
if num_extra_bytes = 0 then p
else p @| (create (16 - num_extra_bytes) 0) | {
"file_name": "vale/specs/crypto/Vale.AES.GCTR_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 45,
"end_line": 43,
"start_col": 0,
"start_line": 37
} | module Vale.AES.GCTR_s
// IMPORTANT: Following NIST's specification, this spec is written assuming a big-endian mapping from bytes to quad32s
// Since the AES spec (AES_s) is in little-endian, we need to byteswap each time we call AES
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
open Vale.AES.AES_s
open FStar.Seq
// The max length of pow2_32 corresponds to the max length of buffers in Low*
// length plain < pow2_32 <= spec max of 2**39 - 256;
let is_gctr_plain_LE (p:seq nat8) : prop0 = length p < pow2_32
type gctr_plain_LE:eqtype = p:seq nat8 { is_gctr_plain_LE p }
type gctr_plain_internal_LE:eqtype = seq quad32
let inc32 (cb:quad32) (i:int) : quad32 =
Mkfour ((cb.lo0 + i) % pow2_32) cb.lo1 cb.hi2 cb.hi3
let gctr_encrypt_block (icb_BE:quad32) (plain_LE:quad32) (alg:algorithm) (key:seq nat32) (i:int) : Pure quad32
(requires is_aes_key_LE alg key)
(ensures fun _ -> True)
=
let icb_LE = reverse_bytes_quad32 (inc32 icb_BE i) in
quad32_xor plain_LE (aes_encrypt_LE alg key icb_LE)
let rec gctr_encrypt_recursive (icb_BE:quad32) (plain:gctr_plain_internal_LE)
(alg:algorithm) (key:aes_key_LE alg) (i:int) : Tot (seq quad32) (decreases %[length plain]) =
if length plain = 0 then empty
else
cons (gctr_encrypt_block icb_BE (head plain) alg key i) (gctr_encrypt_recursive icb_BE (tail plain) alg key (i + 1)) | {
"checked_file": "/",
"dependencies": [
"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.AES.AES_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.GCTR_s.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: FStar.Seq.Base.seq Vale.Def.Types_s.nat8 -> Prims.Pure (FStar.Seq.Base.seq Vale.Def.Types_s.nat8) | Prims.Pure | [] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat8",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"FStar.Seq.Base.op_At_Bar",
"FStar.Seq.Base.create",
"Prims.op_Subtraction",
"Prims.op_Modulus",
"FStar.Seq.Base.length",
"Prims.l_True",
"Prims.l_and",
"Prims.eq2",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition"
] | [] | false | false | false | false | false | let pad_to_128_bits (p: seq nat8)
: Pure (seq nat8)
(requires True)
(ensures fun q -> length q % 16 == 0 /\ length q <= length p + 15) =
| let num_extra_bytes = length p % 16 in
if num_extra_bytes = 0 then p else p @| (create (16 - num_extra_bytes) 0) | false |
Vale.AES.GCTR_s.fst | Vale.AES.GCTR_s.gctr_encrypt_block | val gctr_encrypt_block (icb_BE plain_LE: quad32) (alg: algorithm) (key: seq nat32) (i: int)
: Pure quad32 (requires is_aes_key_LE alg key) (ensures fun _ -> True) | val gctr_encrypt_block (icb_BE plain_LE: quad32) (alg: algorithm) (key: seq nat32) (i: int)
: Pure quad32 (requires is_aes_key_LE alg key) (ensures fun _ -> True) | let gctr_encrypt_block (icb_BE:quad32) (plain_LE:quad32) (alg:algorithm) (key:seq nat32) (i:int) : Pure quad32
(requires is_aes_key_LE alg key)
(ensures fun _ -> True)
=
let icb_LE = reverse_bytes_quad32 (inc32 icb_BE i) in
quad32_xor plain_LE (aes_encrypt_LE alg key icb_LE) | {
"file_name": "vale/specs/crypto/Vale.AES.GCTR_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 53,
"end_line": 28,
"start_col": 0,
"start_line": 23
} | module Vale.AES.GCTR_s
// IMPORTANT: Following NIST's specification, this spec is written assuming a big-endian mapping from bytes to quad32s
// Since the AES spec (AES_s) is in little-endian, we need to byteswap each time we call AES
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
open Vale.AES.AES_s
open FStar.Seq
// The max length of pow2_32 corresponds to the max length of buffers in Low*
// length plain < pow2_32 <= spec max of 2**39 - 256;
let is_gctr_plain_LE (p:seq nat8) : prop0 = length p < pow2_32
type gctr_plain_LE:eqtype = p:seq nat8 { is_gctr_plain_LE p }
type gctr_plain_internal_LE:eqtype = seq quad32
let inc32 (cb:quad32) (i:int) : quad32 =
Mkfour ((cb.lo0 + i) % pow2_32) cb.lo1 cb.hi2 cb.hi3 | {
"checked_file": "/",
"dependencies": [
"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.AES.AES_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.GCTR_s.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
icb_BE: Vale.Def.Types_s.quad32 ->
plain_LE: Vale.Def.Types_s.quad32 ->
alg: Vale.AES.AES_common_s.algorithm ->
key: FStar.Seq.Base.seq Vale.Def.Types_s.nat32 ->
i: Prims.int
-> Prims.Pure Vale.Def.Types_s.quad32 | Prims.Pure | [] | [] | [
"Vale.Def.Types_s.quad32",
"Vale.AES.AES_common_s.algorithm",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat32",
"Prims.int",
"Vale.Def.Types_s.quad32_xor",
"Vale.AES.AES_s.aes_encrypt_LE",
"Vale.Def.Types_s.reverse_bytes_quad32",
"Vale.AES.GCTR_s.inc32",
"Vale.AES.AES_s.is_aes_key_LE",
"Prims.l_True"
] | [] | false | false | false | false | false | let gctr_encrypt_block (icb_BE plain_LE: quad32) (alg: algorithm) (key: seq nat32) (i: int)
: Pure quad32 (requires is_aes_key_LE alg key) (ensures fun _ -> True) =
| let icb_LE = reverse_bytes_quad32 (inc32 icb_BE i) in
quad32_xor plain_LE (aes_encrypt_LE alg key icb_LE) | false |
Vale.AES.GCTR_s.fst | Vale.AES.GCTR_s.gctr_encrypt_recursive | val gctr_encrypt_recursive
(icb_BE: quad32)
(plain: gctr_plain_internal_LE)
(alg: algorithm)
(key: aes_key_LE alg)
(i: int)
: Tot (seq quad32) (decreases %[length plain]) | val gctr_encrypt_recursive
(icb_BE: quad32)
(plain: gctr_plain_internal_LE)
(alg: algorithm)
(key: aes_key_LE alg)
(i: int)
: Tot (seq quad32) (decreases %[length plain]) | let rec gctr_encrypt_recursive (icb_BE:quad32) (plain:gctr_plain_internal_LE)
(alg:algorithm) (key:aes_key_LE alg) (i:int) : Tot (seq quad32) (decreases %[length plain]) =
if length plain = 0 then empty
else
cons (gctr_encrypt_block icb_BE (head plain) alg key i) (gctr_encrypt_recursive icb_BE (tail plain) alg key (i + 1)) | {
"file_name": "vale/specs/crypto/Vale.AES.GCTR_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 120,
"end_line": 35,
"start_col": 0,
"start_line": 31
} | module Vale.AES.GCTR_s
// IMPORTANT: Following NIST's specification, this spec is written assuming a big-endian mapping from bytes to quad32s
// Since the AES spec (AES_s) is in little-endian, we need to byteswap each time we call AES
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
open Vale.AES.AES_s
open FStar.Seq
// The max length of pow2_32 corresponds to the max length of buffers in Low*
// length plain < pow2_32 <= spec max of 2**39 - 256;
let is_gctr_plain_LE (p:seq nat8) : prop0 = length p < pow2_32
type gctr_plain_LE:eqtype = p:seq nat8 { is_gctr_plain_LE p }
type gctr_plain_internal_LE:eqtype = seq quad32
let inc32 (cb:quad32) (i:int) : quad32 =
Mkfour ((cb.lo0 + i) % pow2_32) cb.lo1 cb.hi2 cb.hi3
let gctr_encrypt_block (icb_BE:quad32) (plain_LE:quad32) (alg:algorithm) (key:seq nat32) (i:int) : Pure quad32
(requires is_aes_key_LE alg key)
(ensures fun _ -> True)
=
let icb_LE = reverse_bytes_quad32 (inc32 icb_BE i) in
quad32_xor plain_LE (aes_encrypt_LE alg key icb_LE) | {
"checked_file": "/",
"dependencies": [
"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.AES.AES_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.GCTR_s.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
icb_BE: Vale.Def.Types_s.quad32 ->
plain: Vale.AES.GCTR_s.gctr_plain_internal_LE ->
alg: Vale.AES.AES_common_s.algorithm ->
key: Vale.AES.AES_s.aes_key_LE alg ->
i: Prims.int
-> Prims.Tot (FStar.Seq.Base.seq Vale.Def.Types_s.quad32) | Prims.Tot | [
"total",
""
] | [] | [
"Vale.Def.Types_s.quad32",
"Vale.AES.GCTR_s.gctr_plain_internal_LE",
"Vale.AES.AES_common_s.algorithm",
"Vale.AES.AES_s.aes_key_LE",
"Prims.int",
"Prims.op_Equality",
"FStar.Seq.Base.length",
"FStar.Seq.Base.empty",
"Prims.bool",
"FStar.Seq.Base.cons",
"Vale.AES.GCTR_s.gctr_encrypt_block",
"FStar.Seq.Properties.head",
"Vale.AES.GCTR_s.gctr_encrypt_recursive",
"FStar.Seq.Properties.tail",
"Prims.op_Addition",
"FStar.Seq.Base.seq"
] | [
"recursion"
] | false | false | false | false | false | let rec gctr_encrypt_recursive
(icb_BE: quad32)
(plain: gctr_plain_internal_LE)
(alg: algorithm)
(key: aes_key_LE alg)
(i: int)
: Tot (seq quad32) (decreases %[length plain]) =
| if length plain = 0
then empty
else
cons (gctr_encrypt_block icb_BE (head plain) alg key i)
(gctr_encrypt_recursive icb_BE (tail plain) alg key (i + 1)) | false |
Vale.Lib.MapTree.fsti | Vale.Lib.MapTree.is_cmp | val is_cmp : is_le: (_: a -> _: a -> Prims.bool) -> Prims.logical | let is_cmp (#a:eqtype) (is_le:a -> a -> bool) =
(forall (x y:a).{:pattern is_le x y} is_le x y \/ is_le y x) /\
(forall (x y:a).{:pattern is_le x y} is_le x y /\ is_le y x ==> x == y) /\
(forall (x y z:a).{:pattern is_le x y; is_le y z} is_le x y /\ is_le y z ==> is_le x z) | {
"file_name": "vale/code/lib/collections/Vale.Lib.MapTree.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 89,
"end_line": 9,
"start_col": 0,
"start_line": 6
} | module Vale.Lib.MapTree
open FStar.Mul
(** Balanced binary search tree *) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Lib.MapTree.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | is_le: (_: a -> _: a -> Prims.bool) -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"Prims.bool",
"Prims.l_and",
"Prims.l_Forall",
"Prims.l_or",
"Prims.b2t",
"Prims.l_imp",
"Prims.eq2",
"Prims.logical"
] | [] | false | false | false | false | true | let is_cmp (#a: eqtype) (is_le: (a -> a -> bool)) =
| (forall (x: a) (y: a). {:pattern is_le x y} is_le x y \/ is_le y x) /\
(forall (x: a) (y: a). {:pattern is_le x y} is_le x y /\ is_le y x ==> x == y) /\
(forall (x: a) (y: a) (z: a). {:pattern is_le x y; is_le y z} is_le x y /\ is_le y z ==> is_le x z) | false |
|
Vale.Curve25519.X64.FastUtil.fsti | Vale.Curve25519.X64.FastUtil.va_ens_Cswap2_stdcall | val va_ens_Cswap2_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(bit_in: nat64)
(p0_b p1_b: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop | val va_ens_Cswap2_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(bit_in: nat64)
(p0_b p1_b: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop | let va_ens_Cswap2_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (bit_in:nat64)
(p0_b:buffer64) (p1_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Cswap2_stdcall va_b0 va_s0 win bit_in p0_b p1_b /\ va_ensure_total va_b0 va_s0 va_sM
va_fM /\ va_get_ok va_sM /\ (let (p0_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (p1_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let (old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0)
in let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem
va_s0) in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2
(va_get_mem va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
3 (va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let
(old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in
let (old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0)
in let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem
va_s0) in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2
(va_get_mem va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
3 (va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let
(old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in
let p0_0 = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_sM) in let p0_1 =
Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let p0_2 =
Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == (if (bit_in = 1) then
old_p1_0 else old_p0_0) /\ p0_1 == (if (bit_in = 1) then old_p1_1 else old_p0_1) /\ p0_2 == (if
(bit_in = 1) then old_p1_2 else old_p0_2) /\ p0_3 == (if (bit_in = 1) then old_p1_3 else
old_p0_3) /\ p0_4 == (if (bit_in = 1) then old_p1_4 else old_p0_4) /\ p0_5 == (if (bit_in = 1)
then old_p1_5 else old_p0_5) /\ p0_6 == (if (bit_in = 1) then old_p1_6 else old_p0_6) /\ p0_7
== (if (bit_in = 1) then old_p1_7 else old_p0_7) /\ p1_0 == (if (bit_in = 1) then old_p0_0 else
old_p1_0) /\ p1_1 == (if (bit_in = 1) then old_p0_1 else old_p1_1) /\ p1_2 == (if (bit_in = 1)
then old_p0_2 else old_p1_2) /\ p1_3 == (if (bit_in = 1) then old_p0_3 else old_p1_3) /\ p1_4
== (if (bit_in = 1) then old_p0_4 else old_p1_4) /\ p1_5 == (if (bit_in = 1) then old_p0_5 else
old_p1_5) /\ p1_6 == (if (bit_in = 1) then old_p0_6 else old_p1_6) /\ p1_7 == (if (bit_in = 1)
then old_p0_7 else old_p1_7) /\ Vale.X64.Decls.modifies_buffer_2 p0_b p1_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==>
va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64
rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM
(va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM
(va_update_reg64 rRdx va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))) | {
"file_name": "obj/Vale.Curve25519.X64.FastUtil.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 93,
"end_line": 655,
"start_col": 0,
"start_line": 599
} | module Vale.Curve25519.X64.FastUtil
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Fast_add1
val va_code_Fast_add1 : va_dummy:unit -> Tot va_code
val va_codegen_success_Fast_add1 : va_dummy:unit -> Tot va_pbool
let va_req_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
: prop =
(va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0))
let va_ens_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1 va_b0 va_s0 dst_b inA_b inB /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fast_add1 : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
adx_enabled /\ bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0)
(va_get_mem va_s0) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rdx:nat64) (va_x_r8:nat64)
(va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64) (va_x_heap0:vale_heap)
(va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11
va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8
(va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) ==> va_k va_sM (())))
val va_wpProof_Fast_add1 : dst_b:buffer64 -> inA_b:buffer64 -> inB:nat64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_add1 dst_b inA_b inB va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_add1 ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) : (va_quickCode unit
(va_code_Fast_add1 ())) =
(va_QProc (va_code_Fast_add1 ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx;
va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fast_add1 dst_b inA_b inB) (va_wpProof_Fast_add1 dst_b
inA_b inB))
//--
//-- Fast_add1_stdcall
val va_code_Fast_add1_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fast_add1_stdcall : win:bool -> Tot va_pbool
let va_req_Fast_add1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) : prop =
(va_require_total va_b0 (va_code_Fast_add1_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret))
let va_ens_Fast_add1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1_stdcall va_b0 va_s0 win dst_b inA_b inB_in /\ va_ensure_total va_b0 va_s0 va_sM
va_fM /\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fast_add1_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_in:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_add1_stdcall win) va_s0 /\ va_get_ok va_s0 /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let a0 = Vale.X64.Decls.buffer64_read
inA_b 0 (va_get_mem va_s0) in let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0)
in let a2 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fast_add1_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_in:nat64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in =
va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rbx:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64) (va_x_rbp:nat64)
(va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64)
(va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let a0 =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) ==> va_k va_sM (())))
val va_wpProof_Fast_add1_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_in:nat64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_add1_stdcall win dst_b inA_b inB_in va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_add1_stdcall win)
([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags;
va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10;
va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi;
va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax;
va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_add1_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_in:nat64) :
(va_quickCode unit (va_code_Fast_add1_stdcall win)) =
(va_QProc (va_code_Fast_add1_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fast_add1_stdcall win dst_b inA_b
inB_in) (va_wpProof_Fast_add1_stdcall win dst_b inA_b inB_in))
//--
//-- Cswap2
val va_code_Cswap2 : va_dummy:unit -> Tot va_code
val va_codegen_success_Cswap2 : va_dummy:unit -> Tot va_pbool
let va_req_Cswap2 (va_b0:va_code) (va_s0:va_state) (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64) :
prop =
(va_require_total va_b0 (va_code_Cswap2 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in
let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0)
in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem
va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3
(va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in let
(old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in
let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0)
in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem
va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3
(va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ bit_in == va_get_reg64 rRdi va_s0 /\
va_get_reg64 rRdi va_s0 <= 1 /\ (Vale.X64.Decls.buffers_disjoint p1_b p0_b \/ p1_b == p0_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRsi va_s0) p0_b 8
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdx va_s0) p1_b 8 (va_get_mem_layout va_s0) Secret))
let va_ens_Cswap2 (va_b0:va_code) (va_s0:va_state) (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Cswap2 va_b0 va_s0 bit_in p0_b p1_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0
(va_get_mem va_s0) in let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
1 (va_get_mem va_s0) in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 2 (va_get_mem va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_s0) in let
(old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in
let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0)
in let (old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem
va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0
(va_get_mem va_s0) in let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
1 (va_get_mem va_s0) in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 2 (va_get_mem va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_s0) in let
(old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in
let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0)
in let (old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem
va_s0) in Vale.X64.Decls.modifies_buffer_2 p0_b p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\
(let p0_0 = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_sM) in let p0_1 =
Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let p0_2 =
Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == (if (va_get_reg64 rRdi va_s0
= 1) then old_p1_0 else old_p0_0) /\ p0_1 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_1
else old_p0_1) /\ p0_2 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_2 else old_p0_2) /\
p0_3 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_3 else old_p0_3) /\ p0_4 == (if
(va_get_reg64 rRdi va_s0 = 1) then old_p1_4 else old_p0_4) /\ p0_5 == (if (va_get_reg64 rRdi
va_s0 = 1) then old_p1_5 else old_p0_5) /\ p0_6 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p1_6 else old_p0_6) /\ p0_7 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_7 else
old_p0_7) /\ p1_0 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_0 else old_p1_0) /\ p1_1 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_1 else old_p1_1) /\ p1_2 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_2 else old_p1_2) /\ p1_3 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p0_3 else old_p1_3) /\ p1_4 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_4 else
old_p1_4) /\ p1_5 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_5 else old_p1_5) /\ p1_6 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_6 else old_p1_6) /\ p1_7 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_7 else old_p1_7))) /\ va_state_eq va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdi va_sM (va_update_ok
va_sM (va_update_mem va_sM va_s0))))))))))
val va_lemma_Cswap2 : va_b0:va_code -> va_s0:va_state -> bit_in:nat64 -> p0_b:buffer64 ->
p1_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Cswap2 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in
let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0)
in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem
va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3
(va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in let
(old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in
let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0)
in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem
va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3
(va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ bit_in == va_get_reg64 rRdi va_s0 /\
va_get_reg64 rRdi va_s0 <= 1 /\ (Vale.X64.Decls.buffers_disjoint p1_b p0_b \/ p1_b == p0_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRsi va_s0) p0_b 8
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdx va_s0) p1_b 8 (va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0)
in let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem
va_s0) in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2
(va_get_mem va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
3 (va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let
(old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in
let (old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0)
in let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem
va_s0) in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2
(va_get_mem va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
3 (va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let
(old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in
Vale.X64.Decls.modifies_buffer_2 p0_b p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (let p0_0 =
Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_sM) in let p0_1 =
Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let p0_2 =
Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == (if (va_get_reg64 rRdi va_s0
= 1) then old_p1_0 else old_p0_0) /\ p0_1 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_1
else old_p0_1) /\ p0_2 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_2 else old_p0_2) /\
p0_3 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_3 else old_p0_3) /\ p0_4 == (if
(va_get_reg64 rRdi va_s0 = 1) then old_p1_4 else old_p0_4) /\ p0_5 == (if (va_get_reg64 rRdi
va_s0 = 1) then old_p1_5 else old_p0_5) /\ p0_6 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p1_6 else old_p0_6) /\ p0_7 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_7 else
old_p0_7) /\ p1_0 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_0 else old_p1_0) /\ p1_1 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_1 else old_p1_1) /\ p1_2 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_2 else old_p1_2) /\ p1_3 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p0_3 else old_p1_3) /\ p1_4 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_4 else
old_p1_4) /\ p1_5 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_5 else old_p1_5) /\ p1_6 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_6 else old_p1_6) /\ p1_7 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_7 else old_p1_7))) /\ va_state_eq va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdi va_sM (va_update_ok
va_sM (va_update_mem va_sM va_s0)))))))))))
[@ va_qattr]
let va_wp_Cswap2 (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0
(va_get_mem va_s0) in let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
1 (va_get_mem va_s0) in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 2 (va_get_mem va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_s0) in let
(old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in
let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0)
in let (old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem
va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0
(va_get_mem va_s0) in let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
1 (va_get_mem va_s0) in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 2 (va_get_mem va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_s0) in let
(old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in
let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0)
in let (old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem
va_s0) in Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
bit_in == va_get_reg64 rRdi va_s0 /\ va_get_reg64 rRdi va_s0 <= 1 /\
(Vale.X64.Decls.buffers_disjoint p1_b p0_b \/ p1_b == p0_b) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) p0_b 8 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) p1_b 8
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rdi:nat64)
(va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) . let va_sM = va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags va_x_efl (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdi va_x_rdi
(va_upd_mem va_x_mem va_s0))))))) in va_get_ok va_sM /\ (let (old_p0_0:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in let
(old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0) in
let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_s0)
in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem
va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 4
(va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in let
(old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0) in
let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_s0)
in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem
va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 4
(va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in Vale.X64.Decls.modifies_buffer_2 p0_b
p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (let p0_0 = Vale.X64.Decls.buffer64_read p0_b 0
(va_get_mem va_sM) in let p0_1 = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let
p0_2 = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == va_if (va_get_reg64 rRdi
va_s0 = 1) (fun _ -> old_p1_0) (fun _ -> old_p0_0) /\ p0_1 == va_if (va_get_reg64 rRdi va_s0 =
1) (fun _ -> old_p1_1) (fun _ -> old_p0_1) /\ p0_2 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun
_ -> old_p1_2) (fun _ -> old_p0_2) /\ p0_3 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_3) (fun _ -> old_p0_3) /\ p0_4 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_4) (fun _ -> old_p0_4) /\ p0_5 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_5) (fun _ -> old_p0_5) /\ p0_6 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_6) (fun _ -> old_p0_6) /\ p0_7 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_7) (fun _ -> old_p0_7) /\ p1_0 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_0) (fun _ -> old_p1_0) /\ p1_1 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_1) (fun _ -> old_p1_1) /\ p1_2 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_2) (fun _ -> old_p1_2) /\ p1_3 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_3) (fun _ -> old_p1_3) /\ p1_4 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_4) (fun _ -> old_p1_4) /\ p1_5 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_5) (fun _ -> old_p1_5) /\ p1_6 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_6) (fun _ -> old_p1_6) /\ p1_7 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_7) (fun _ -> old_p1_7))) ==> va_k va_sM (())))
val va_wpProof_Cswap2 : bit_in:nat64 -> p0_b:buffer64 -> p1_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Cswap2 bit_in p0_b p1_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Cswap2 ()) ([va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdi; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Cswap2 (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64) : (va_quickCode unit
(va_code_Cswap2 ())) =
(va_QProc (va_code_Cswap2 ()) ([va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags;
va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdi; va_Mod_mem])
(va_wp_Cswap2 bit_in p0_b p1_b) (va_wpProof_Cswap2 bit_in p0_b p1_b))
//--
//-- Cswap2_stdcall
val va_code_Cswap2_stdcall : win:bool -> Tot va_code
val va_codegen_success_Cswap2_stdcall : win:bool -> Tot va_pbool
let va_req_Cswap2_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (bit_in:nat64)
(p0_b:buffer64) (p1_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Cswap2_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(p0_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else
va_get_reg64 rRsi va_s0) in let (p1_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in let (old_p0_0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in let (old_p0_1:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0) in let
(old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_s0) in
let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0)
in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem
va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 5
(va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 7 (va_get_mem va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in let (old_p1_1:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0) in let
(old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_s0) in
let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0)
in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem
va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 5
(va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 7 (va_get_mem va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack
va_s0) /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
bit_in <= 1 /\ bit_in = (if win then va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) /\
(Vale.X64.Decls.buffers_disjoint p0_b p1_b \/ p1_b == p0_b) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) p0_in p0_b 8 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) p1_in p1_b 8 (va_get_mem_layout va_s0) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastUtil.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
win: Prims.bool ->
bit_in: Vale.X64.Memory.nat64 ->
p0_b: Vale.X64.Memory.buffer64 ->
p1_b: Vale.X64.Memory.buffer64 ->
va_sM: Vale.X64.Decls.va_state ->
va_fM: Vale.X64.Decls.va_fuel
-> Prims.prop | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Prims.bool",
"Vale.X64.Memory.nat64",
"Vale.X64.Memory.buffer64",
"Vale.X64.Decls.va_fuel",
"Prims.l_and",
"Vale.Curve25519.X64.FastUtil.va_req_Cswap2_stdcall",
"Vale.X64.Decls.va_ensure_total",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.eq2",
"Vale.Def.Words_s.nat64",
"Prims.op_Equality",
"Prims.int",
"Vale.X64.Decls.modifies_buffer_2",
"Vale.X64.Decls.va_get_mem",
"Prims.l_imp",
"Vale.Def.Types_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRdi",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Decls.buffer64_read",
"Vale.X64.Decls.va_int_range",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_stackTaint",
"Vale.X64.Decls.va_update_stack",
"Vale.X64.Decls.va_update_mem_layout",
"Vale.X64.Decls.va_update_mem_heaplet",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_reg64",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_mem",
"Prims.prop"
] | [] | false | false | false | true | true | let va_ens_Cswap2_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(bit_in: nat64)
(p0_b p1_b: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop =
| (va_req_Cswap2_stdcall va_b0 va_s0 win bit_in p0_b p1_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\
(let p0_in:(va_int_range 0 18446744073709551615) =
(if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0)
in
let p1_in:(va_int_range 0 18446744073709551615) =
(if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0)
in
let old_p0_0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in
let old_p0_1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0) in
let old_p0_2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_s0) in
let old_p0_3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0) in
let old_p0_4:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_s0) in
let old_p0_5:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in
let old_p0_6:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in
let old_p0_7:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in
let old_p1_0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in
let old_p1_1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0) in
let old_p1_2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_s0) in
let old_p1_3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0) in
let old_p1_4:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_s0) in
let old_p1_5:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in
let old_p1_6:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in
let old_p1_7:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in
let p0_0 = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_sM) in
let p0_1 = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in
let p0_2 = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in
let p0_3 = Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in
let p0_4 = Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in
let p0_5 = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in
let p0_6 = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in
let p0_7 = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in
let p1_0 = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in
let p1_1 = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in
let p1_2 = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in
let p1_3 = Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in
let p1_4 = Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in
let p1_5 = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in
let p1_6 = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in
let p1_7 = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in
p0_0 == (if (bit_in = 1) then old_p1_0 else old_p0_0) /\
p0_1 == (if (bit_in = 1) then old_p1_1 else old_p0_1) /\
p0_2 == (if (bit_in = 1) then old_p1_2 else old_p0_2) /\
p0_3 == (if (bit_in = 1) then old_p1_3 else old_p0_3) /\
p0_4 == (if (bit_in = 1) then old_p1_4 else old_p0_4) /\
p0_5 == (if (bit_in = 1) then old_p1_5 else old_p0_5) /\
p0_6 == (if (bit_in = 1) then old_p1_6 else old_p0_6) /\
p0_7 == (if (bit_in = 1) then old_p1_7 else old_p0_7) /\
p1_0 == (if (bit_in = 1) then old_p0_0 else old_p1_0) /\
p1_1 == (if (bit_in = 1) then old_p0_1 else old_p1_1) /\
p1_2 == (if (bit_in = 1) then old_p0_2 else old_p1_2) /\
p1_3 == (if (bit_in = 1) then old_p0_3 else old_p1_3) /\
p1_4 == (if (bit_in = 1) then old_p0_4 else old_p1_4) /\
p1_5 == (if (bit_in = 1) then old_p0_5 else old_p1_5) /\
p1_6 == (if (bit_in = 1) then old_p0_6 else old_p1_6) /\
p1_7 == (if (bit_in = 1) then old_p0_7 else old_p1_7) /\
Vale.X64.Decls.modifies_buffer_2 p0_b p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\
(win ==> va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\
(win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM
(va_update_stackTaint va_sM
(va_update_stack va_sM
(va_update_mem_layout va_sM
(va_update_mem_heaplet 0
va_sM
(va_update_flags va_sM
(va_update_reg64 rR10
va_sM
(va_update_reg64 rR9
va_sM
(va_update_reg64 rR8
va_sM
(va_update_reg64 rRsp
va_sM
(va_update_reg64 rRdi
va_sM
(va_update_reg64 rRsi
va_sM
(va_update_reg64 rRdx
va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))
))))))))))))) | false |
Vale.Curve25519.X64.FastUtil.fsti | Vale.Curve25519.X64.FastUtil.va_wp_Cswap2_stdcall | val va_wp_Cswap2_stdcall
(win: bool)
(bit_in: nat64)
(p0_b p1_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Cswap2_stdcall
(win: bool)
(bit_in: nat64)
(p0_b p1_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Cswap2_stdcall (win:bool) (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (p0_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (p1_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let (old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0
(va_get_mem va_s0) in let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
1 (va_get_mem va_s0) in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 2 (va_get_mem va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_s0) in let
(old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in
let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0)
in let (old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem
va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0
(va_get_mem va_s0) in let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
1 (va_get_mem va_s0) in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 2 (va_get_mem va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_s0) in let
(old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in
let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0)
in let (old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem
va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ bit_in <= 1 /\
bit_in = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) /\
(Vale.X64.Decls.buffers_disjoint p0_b p1_b \/ p1_b == p0_b) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) p0_in p0_b 8 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) p1_in p1_b 8 (va_get_mem_layout va_s0)
Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8
(va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRdi va_x_rdi (va_upd_reg64 rRsi va_x_rsi
(va_upd_reg64 rRdx va_x_rdx (va_upd_mem va_x_mem va_s0)))))))))))) in va_get_ok va_sM /\ (let
(p0_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0)
(fun _ -> va_get_reg64 rRsi va_s0) in let (p1_in:(va_int_range 0 18446744073709551615)) = va_if
win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in let
(old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in
let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0)
in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem
va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3
(va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in let
(old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in
let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0)
in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem
va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3
(va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in let p0_0 =
Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_sM) in let p0_1 =
Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let p0_2 =
Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == va_if (bit_in = 1) (fun _ ->
old_p1_0) (fun _ -> old_p0_0) /\ p0_1 == va_if (bit_in = 1) (fun _ -> old_p1_1) (fun _ ->
old_p0_1) /\ p0_2 == va_if (bit_in = 1) (fun _ -> old_p1_2) (fun _ -> old_p0_2) /\ p0_3 ==
va_if (bit_in = 1) (fun _ -> old_p1_3) (fun _ -> old_p0_3) /\ p0_4 == va_if (bit_in = 1) (fun _
-> old_p1_4) (fun _ -> old_p0_4) /\ p0_5 == va_if (bit_in = 1) (fun _ -> old_p1_5) (fun _ ->
old_p0_5) /\ p0_6 == va_if (bit_in = 1) (fun _ -> old_p1_6) (fun _ -> old_p0_6) /\ p0_7 ==
va_if (bit_in = 1) (fun _ -> old_p1_7) (fun _ -> old_p0_7) /\ p1_0 == va_if (bit_in = 1) (fun _
-> old_p0_0) (fun _ -> old_p1_0) /\ p1_1 == va_if (bit_in = 1) (fun _ -> old_p0_1) (fun _ ->
old_p1_1) /\ p1_2 == va_if (bit_in = 1) (fun _ -> old_p0_2) (fun _ -> old_p1_2) /\ p1_3 ==
va_if (bit_in = 1) (fun _ -> old_p0_3) (fun _ -> old_p1_3) /\ p1_4 == va_if (bit_in = 1) (fun _
-> old_p0_4) (fun _ -> old_p1_4) /\ p1_5 == va_if (bit_in = 1) (fun _ -> old_p0_5) (fun _ ->
old_p1_5) /\ p1_6 == va_if (bit_in = 1) (fun _ -> old_p0_6) (fun _ -> old_p1_6) /\ p1_7 ==
va_if (bit_in = 1) (fun _ -> old_p0_7) (fun _ -> old_p1_7) /\ Vale.X64.Decls.modifies_buffer_2
p0_b p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.Curve25519.X64.FastUtil.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 77,
"end_line": 831,
"start_col": 0,
"start_line": 743
} | module Vale.Curve25519.X64.FastUtil
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Fast_add1
val va_code_Fast_add1 : va_dummy:unit -> Tot va_code
val va_codegen_success_Fast_add1 : va_dummy:unit -> Tot va_pbool
let va_req_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
: prop =
(va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0))
let va_ens_Fast_add1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1 va_b0 va_s0 dst_b inA_b inB /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fast_add1 : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_add1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled
/\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
adx_enabled /\ bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0)
(va_get_mem va_s0) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\ inB == va_get_reg64 rRdx
va_s0) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rdx:nat64) (va_x_r8:nat64)
(va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64) (va_x_heap0:vale_heap)
(va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11
va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8
(va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a +
va_get_reg64 rRdx va_s0 /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem
va_sM)) ==> va_k va_sM (())))
val va_wpProof_Fast_add1 : dst_b:buffer64 -> inA_b:buffer64 -> inB:nat64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_add1 dst_b inA_b inB va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_add1 ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_add1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) : (va_quickCode unit
(va_code_Fast_add1 ())) =
(va_QProc (va_code_Fast_add1 ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx;
va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fast_add1 dst_b inA_b inB) (va_wpProof_Fast_add1 dst_b
inA_b inB))
//--
//-- Fast_add1_stdcall
val va_code_Fast_add1_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fast_add1_stdcall : win:bool -> Tot va_pbool
let va_req_Fast_add1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) : prop =
(va_require_total va_b0 (va_code_Fast_add1_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret))
let va_ens_Fast_add1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fast_add1_stdcall va_b0 va_s0 win dst_b inA_b inB_in /\ va_ensure_total va_b0 va_s0 va_sM
va_fM /\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fast_add1_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_in:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_add1_stdcall win) va_s0 /\ va_get_ok va_s0 /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let a0 = Vale.X64.Decls.buffer64_read
inA_b 0 (va_get_mem va_s0) in let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0)
in let a2 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fast_add1_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_in:nat64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in =
va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rbx:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64) (va_x_rbp:nat64)
(va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64)
(va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let a0 =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_five
d0 d1 d2 d3 (va_get_reg64 rRax va_sM) in d == a + inB_in /\ Vale.X64.Decls.modifies_buffer
dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==>
va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM ==
va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14
va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15
va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM ==
va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) ==> va_k va_sM (())))
val va_wpProof_Fast_add1_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_in:nat64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_add1_stdcall win dst_b inA_b inB_in va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_add1_stdcall win)
([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags;
va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10;
va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi;
va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax;
va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_add1_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_in:nat64) :
(va_quickCode unit (va_code_Fast_add1_stdcall win)) =
(va_QProc (va_code_Fast_add1_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fast_add1_stdcall win dst_b inA_b
inB_in) (va_wpProof_Fast_add1_stdcall win dst_b inA_b inB_in))
//--
//-- Cswap2
val va_code_Cswap2 : va_dummy:unit -> Tot va_code
val va_codegen_success_Cswap2 : va_dummy:unit -> Tot va_pbool
let va_req_Cswap2 (va_b0:va_code) (va_s0:va_state) (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64) :
prop =
(va_require_total va_b0 (va_code_Cswap2 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in
let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0)
in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem
va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3
(va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in let
(old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in
let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0)
in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem
va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3
(va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ bit_in == va_get_reg64 rRdi va_s0 /\
va_get_reg64 rRdi va_s0 <= 1 /\ (Vale.X64.Decls.buffers_disjoint p1_b p0_b \/ p1_b == p0_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRsi va_s0) p0_b 8
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdx va_s0) p1_b 8 (va_get_mem_layout va_s0) Secret))
let va_ens_Cswap2 (va_b0:va_code) (va_s0:va_state) (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Cswap2 va_b0 va_s0 bit_in p0_b p1_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0
(va_get_mem va_s0) in let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
1 (va_get_mem va_s0) in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 2 (va_get_mem va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_s0) in let
(old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in
let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0)
in let (old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem
va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0
(va_get_mem va_s0) in let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
1 (va_get_mem va_s0) in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 2 (va_get_mem va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_s0) in let
(old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in
let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0)
in let (old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem
va_s0) in Vale.X64.Decls.modifies_buffer_2 p0_b p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\
(let p0_0 = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_sM) in let p0_1 =
Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let p0_2 =
Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == (if (va_get_reg64 rRdi va_s0
= 1) then old_p1_0 else old_p0_0) /\ p0_1 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_1
else old_p0_1) /\ p0_2 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_2 else old_p0_2) /\
p0_3 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_3 else old_p0_3) /\ p0_4 == (if
(va_get_reg64 rRdi va_s0 = 1) then old_p1_4 else old_p0_4) /\ p0_5 == (if (va_get_reg64 rRdi
va_s0 = 1) then old_p1_5 else old_p0_5) /\ p0_6 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p1_6 else old_p0_6) /\ p0_7 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_7 else
old_p0_7) /\ p1_0 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_0 else old_p1_0) /\ p1_1 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_1 else old_p1_1) /\ p1_2 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_2 else old_p1_2) /\ p1_3 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p0_3 else old_p1_3) /\ p1_4 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_4 else
old_p1_4) /\ p1_5 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_5 else old_p1_5) /\ p1_6 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_6 else old_p1_6) /\ p1_7 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_7 else old_p1_7))) /\ va_state_eq va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdi va_sM (va_update_ok
va_sM (va_update_mem va_sM va_s0))))))))))
val va_lemma_Cswap2 : va_b0:va_code -> va_s0:va_state -> bit_in:nat64 -> p0_b:buffer64 ->
p1_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Cswap2 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in
let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0)
in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem
va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3
(va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in let
(old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in
let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0)
in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem
va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3
(va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ bit_in == va_get_reg64 rRdi va_s0 /\
va_get_reg64 rRdi va_s0 <= 1 /\ (Vale.X64.Decls.buffers_disjoint p1_b p0_b \/ p1_b == p0_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRsi va_s0) p0_b 8
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdx va_s0) p1_b 8 (va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0)
in let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem
va_s0) in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2
(va_get_mem va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
3 (va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let
(old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in
let (old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0)
in let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem
va_s0) in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2
(va_get_mem va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
3 (va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let
(old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in
Vale.X64.Decls.modifies_buffer_2 p0_b p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (let p0_0 =
Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_sM) in let p0_1 =
Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let p0_2 =
Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == (if (va_get_reg64 rRdi va_s0
= 1) then old_p1_0 else old_p0_0) /\ p0_1 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_1
else old_p0_1) /\ p0_2 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_2 else old_p0_2) /\
p0_3 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_3 else old_p0_3) /\ p0_4 == (if
(va_get_reg64 rRdi va_s0 = 1) then old_p1_4 else old_p0_4) /\ p0_5 == (if (va_get_reg64 rRdi
va_s0 = 1) then old_p1_5 else old_p0_5) /\ p0_6 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p1_6 else old_p0_6) /\ p0_7 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p1_7 else
old_p0_7) /\ p1_0 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_0 else old_p1_0) /\ p1_1 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_1 else old_p1_1) /\ p1_2 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_2 else old_p1_2) /\ p1_3 == (if (va_get_reg64 rRdi va_s0 = 1) then
old_p0_3 else old_p1_3) /\ p1_4 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_4 else
old_p1_4) /\ p1_5 == (if (va_get_reg64 rRdi va_s0 = 1) then old_p0_5 else old_p1_5) /\ p1_6 ==
(if (va_get_reg64 rRdi va_s0 = 1) then old_p0_6 else old_p1_6) /\ p1_7 == (if (va_get_reg64
rRdi va_s0 = 1) then old_p0_7 else old_p1_7))) /\ va_state_eq va_sM (va_update_mem_layout va_sM
(va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdi va_sM (va_update_ok
va_sM (va_update_mem va_sM va_s0)))))))))))
[@ va_qattr]
let va_wp_Cswap2 (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0
(va_get_mem va_s0) in let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
1 (va_get_mem va_s0) in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 2 (va_get_mem va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_s0) in let
(old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in
let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0)
in let (old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem
va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0
(va_get_mem va_s0) in let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
1 (va_get_mem va_s0) in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 2 (va_get_mem va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_s0) in let
(old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in
let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0)
in let (old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem
va_s0) in Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
bit_in == va_get_reg64 rRdi va_s0 /\ va_get_reg64 rRdi va_s0 <= 1 /\
(Vale.X64.Decls.buffers_disjoint p1_b p0_b \/ p1_b == p0_b) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) p0_b 8 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) p1_b 8
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rdi:nat64)
(va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) . let va_sM = va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags va_x_efl (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdi va_x_rdi
(va_upd_mem va_x_mem va_s0))))))) in va_get_ok va_sM /\ (let (old_p0_0:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in let
(old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0) in
let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_s0)
in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem
va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 4
(va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in let
(old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0) in
let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_s0)
in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem
va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 4
(va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in Vale.X64.Decls.modifies_buffer_2 p0_b
p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (let p0_0 = Vale.X64.Decls.buffer64_read p0_b 0
(va_get_mem va_sM) in let p0_1 = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let
p0_2 = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == va_if (va_get_reg64 rRdi
va_s0 = 1) (fun _ -> old_p1_0) (fun _ -> old_p0_0) /\ p0_1 == va_if (va_get_reg64 rRdi va_s0 =
1) (fun _ -> old_p1_1) (fun _ -> old_p0_1) /\ p0_2 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun
_ -> old_p1_2) (fun _ -> old_p0_2) /\ p0_3 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_3) (fun _ -> old_p0_3) /\ p0_4 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_4) (fun _ -> old_p0_4) /\ p0_5 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_5) (fun _ -> old_p0_5) /\ p0_6 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_6) (fun _ -> old_p0_6) /\ p0_7 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p1_7) (fun _ -> old_p0_7) /\ p1_0 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_0) (fun _ -> old_p1_0) /\ p1_1 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_1) (fun _ -> old_p1_1) /\ p1_2 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_2) (fun _ -> old_p1_2) /\ p1_3 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_3) (fun _ -> old_p1_3) /\ p1_4 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_4) (fun _ -> old_p1_4) /\ p1_5 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_5) (fun _ -> old_p1_5) /\ p1_6 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_6) (fun _ -> old_p1_6) /\ p1_7 == va_if (va_get_reg64 rRdi va_s0 = 1) (fun _ ->
old_p0_7) (fun _ -> old_p1_7))) ==> va_k va_sM (())))
val va_wpProof_Cswap2 : bit_in:nat64 -> p0_b:buffer64 -> p1_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Cswap2 bit_in p0_b p1_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Cswap2 ()) ([va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdi; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Cswap2 (bit_in:nat64) (p0_b:buffer64) (p1_b:buffer64) : (va_quickCode unit
(va_code_Cswap2 ())) =
(va_QProc (va_code_Cswap2 ()) ([va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags;
va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdi; va_Mod_mem])
(va_wp_Cswap2 bit_in p0_b p1_b) (va_wpProof_Cswap2 bit_in p0_b p1_b))
//--
//-- Cswap2_stdcall
val va_code_Cswap2_stdcall : win:bool -> Tot va_code
val va_codegen_success_Cswap2_stdcall : win:bool -> Tot va_pbool
let va_req_Cswap2_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (bit_in:nat64)
(p0_b:buffer64) (p1_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Cswap2_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(p0_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else
va_get_reg64 rRsi va_s0) in let (p1_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in let (old_p0_0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in let (old_p0_1:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0) in let
(old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_s0) in
let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0)
in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem
va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 5
(va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 7 (va_get_mem va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in let (old_p1_1:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0) in let
(old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_s0) in
let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0)
in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem
va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 5
(va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 7 (va_get_mem va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack
va_s0) /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
bit_in <= 1 /\ bit_in = (if win then va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) /\
(Vale.X64.Decls.buffers_disjoint p0_b p1_b \/ p1_b == p0_b) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) p0_in p0_b 8 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) p1_in p1_b 8 (va_get_mem_layout va_s0)
Secret))
let va_ens_Cswap2_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (bit_in:nat64)
(p0_b:buffer64) (p1_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Cswap2_stdcall va_b0 va_s0 win bit_in p0_b p1_b /\ va_ensure_total va_b0 va_s0 va_sM
va_fM /\ va_get_ok va_sM /\ (let (p0_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (p1_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let (old_p0_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0)
in let (old_p0_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem
va_s0) in let (old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2
(va_get_mem va_s0) in let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
3 (va_get_mem va_s0) in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 4 (va_get_mem va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in let
(old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in
let (old_p1_0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0)
in let (old_p1_1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem
va_s0) in let (old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2
(va_get_mem va_s0) in let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
3 (va_get_mem va_s0) in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 4 (va_get_mem va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in let
(old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in
let p0_0 = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_sM) in let p0_1 =
Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let p0_2 =
Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == (if (bit_in = 1) then
old_p1_0 else old_p0_0) /\ p0_1 == (if (bit_in = 1) then old_p1_1 else old_p0_1) /\ p0_2 == (if
(bit_in = 1) then old_p1_2 else old_p0_2) /\ p0_3 == (if (bit_in = 1) then old_p1_3 else
old_p0_3) /\ p0_4 == (if (bit_in = 1) then old_p1_4 else old_p0_4) /\ p0_5 == (if (bit_in = 1)
then old_p1_5 else old_p0_5) /\ p0_6 == (if (bit_in = 1) then old_p1_6 else old_p0_6) /\ p0_7
== (if (bit_in = 1) then old_p1_7 else old_p0_7) /\ p1_0 == (if (bit_in = 1) then old_p0_0 else
old_p1_0) /\ p1_1 == (if (bit_in = 1) then old_p0_1 else old_p1_1) /\ p1_2 == (if (bit_in = 1)
then old_p0_2 else old_p1_2) /\ p1_3 == (if (bit_in = 1) then old_p0_3 else old_p1_3) /\ p1_4
== (if (bit_in = 1) then old_p0_4 else old_p1_4) /\ p1_5 == (if (bit_in = 1) then old_p0_5 else
old_p1_5) /\ p1_6 == (if (bit_in = 1) then old_p0_6 else old_p1_6) /\ p1_7 == (if (bit_in = 1)
then old_p0_7 else old_p1_7) /\ Vale.X64.Decls.modifies_buffer_2 p0_b p1_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==>
va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64
rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM
(va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM
(va_update_reg64 rRdx va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))))
val va_lemma_Cswap2_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> bit_in:nat64 ->
p0_b:buffer64 -> p1_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Cswap2_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(p0_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else
va_get_reg64 rRsi va_s0) in let (p1_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in let (old_p0_0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in let (old_p0_1:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0) in let
(old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_s0) in
let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0)
in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem
va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 5
(va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 7 (va_get_mem va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in let (old_p1_1:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0) in let
(old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_s0) in
let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0)
in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem
va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 5
(va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 7 (va_get_mem va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack
va_s0) /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
bit_in <= 1 /\ bit_in = (if win then va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) /\
(Vale.X64.Decls.buffers_disjoint p0_b p1_b \/ p1_b == p0_b) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) p0_in p0_b 8 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) p1_in p1_b 8 (va_get_mem_layout va_s0)
Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (p0_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else
va_get_reg64 rRsi va_s0) in let (p1_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in let (old_p0_0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in let (old_p0_1:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0) in let
(old_p0_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_s0) in
let (old_p0_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0)
in let (old_p0_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem
va_s0) in let (old_p0_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b 5
(va_get_mem va_s0) in let (old_p0_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p0_b
6 (va_get_mem va_s0) in let (old_p0_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p0_b 7 (va_get_mem va_s0) in let (old_p1_0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in let (old_p1_1:Vale.Def.Types_s.nat64)
= Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0) in let
(old_p1_2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_s0) in
let (old_p1_3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0)
in let (old_p1_4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem
va_s0) in let (old_p1_5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b 5
(va_get_mem va_s0) in let (old_p1_6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read p1_b
6 (va_get_mem va_s0) in let (old_p1_7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
p1_b 7 (va_get_mem va_s0) in let p0_0 = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_sM)
in let p0_1 = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in let p0_2 =
Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in let p0_3 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in let p0_4 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in let p0_5 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in let p0_6 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in let p0_7 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in let p1_0 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in let p1_1 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in let p1_2 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in let p1_3 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in let p1_4 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in let p1_5 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in let p1_6 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in let p1_7 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in p0_0 == (if (bit_in = 1) then
old_p1_0 else old_p0_0) /\ p0_1 == (if (bit_in = 1) then old_p1_1 else old_p0_1) /\ p0_2 == (if
(bit_in = 1) then old_p1_2 else old_p0_2) /\ p0_3 == (if (bit_in = 1) then old_p1_3 else
old_p0_3) /\ p0_4 == (if (bit_in = 1) then old_p1_4 else old_p0_4) /\ p0_5 == (if (bit_in = 1)
then old_p1_5 else old_p0_5) /\ p0_6 == (if (bit_in = 1) then old_p1_6 else old_p0_6) /\ p0_7
== (if (bit_in = 1) then old_p1_7 else old_p0_7) /\ p1_0 == (if (bit_in = 1) then old_p0_0 else
old_p1_0) /\ p1_1 == (if (bit_in = 1) then old_p0_1 else old_p1_1) /\ p1_2 == (if (bit_in = 1)
then old_p0_2 else old_p1_2) /\ p1_3 == (if (bit_in = 1) then old_p0_3 else old_p1_3) /\ p1_4
== (if (bit_in = 1) then old_p0_4 else old_p1_4) /\ p1_5 == (if (bit_in = 1) then old_p0_5 else
old_p1_5) /\ p1_6 == (if (bit_in = 1) then old_p0_6 else old_p1_6) /\ p1_7 == (if (bit_in = 1)
then old_p0_7 else old_p1_7) /\ Vale.X64.Decls.modifies_buffer_2 p0_b p1_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\ (win ==>
va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64
rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM
(va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM
(va_update_reg64 rRdx va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastUtil.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
win: Prims.bool ->
bit_in: Vale.X64.Memory.nat64 ->
p0_b: Vale.X64.Memory.buffer64 ->
p1_b: Vale.X64.Memory.buffer64 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.bool",
"Vale.X64.Memory.nat64",
"Vale.X64.Memory.buffer64",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.eq2",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Stack_i.init_rsp",
"Vale.X64.Decls.va_get_stack",
"Vale.X64.Memory.is_initial_heap",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Decls.va_get_mem",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Vale.X64.Decls.va_if",
"Vale.Def.Types_s.nat64",
"Vale.X64.Machine_s.rRcx",
"Prims.l_not",
"Vale.X64.Machine_s.rRdi",
"Prims.l_or",
"Vale.X64.Decls.buffers_disjoint",
"Vale.X64.Decls.validDstAddrs64",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.buffer64_read",
"Vale.X64.Decls.va_int_range",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRsi",
"Prims.l_Forall",
"Vale.X64.InsBasic.vale_heap",
"Vale.X64.Flags.t",
"Vale.Arch.HeapImpl.vale_heap_layout",
"Vale.X64.InsBasic.vale_stack",
"Vale.X64.Memory.memtaint",
"Prims.l_imp",
"Prims.int",
"Vale.X64.Decls.modifies_buffer_2",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_stackTaint",
"Vale.X64.Decls.va_upd_stack",
"Vale.X64.Decls.va_upd_mem_layout",
"Vale.X64.Decls.va_upd_mem_heaplet",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_reg64",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Decls.va_upd_mem"
] | [] | false | false | false | true | true | let va_wp_Cswap2_stdcall
(win: bool)
(bit_in: nat64)
(p0_b p1_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_get_ok va_s0 /\
(let p0_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0)
in
let p1_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0)
in
let old_p0_0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0) in
let old_p0_1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0) in
let old_p0_2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_s0) in
let old_p0_3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0) in
let old_p0_4:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_s0) in
let old_p0_5:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0) in
let old_p0_6:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0) in
let old_p0_7:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0) in
let old_p1_0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0) in
let old_p1_1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0) in
let old_p1_2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_s0) in
let old_p1_3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0) in
let old_p1_4:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_s0) in
let old_p1_5:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0) in
let old_p1_6:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0) in
let old_p1_7:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ bit_in <= 1 /\
bit_in = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) /\
(Vale.X64.Decls.buffers_disjoint p0_b p1_b \/ p1_b == p0_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) p0_in p0_b 8 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) p1_in p1_b 8 (va_get_mem_layout va_s0) Secret) /\
(forall (va_x_mem: vale_heap) (va_x_rdx: nat64) (va_x_rsi: nat64) (va_x_rdi: nat64)
(va_x_rsp: nat64) (va_x_r8: nat64) (va_x_r9: nat64) (va_x_r10: nat64)
(va_x_efl: Vale.X64.Flags.t) (va_x_heap0: vale_heap) (va_x_memLayout: vale_heap_layout)
(va_x_stack: vale_stack) (va_x_stackTaint: memtaint).
let va_sM =
va_upd_stackTaint va_x_stackTaint
(va_upd_stack va_x_stack
(va_upd_mem_layout va_x_memLayout
(va_upd_mem_heaplet 0
va_x_heap0
(va_upd_flags va_x_efl
(va_upd_reg64 rR10
va_x_r10
(va_upd_reg64 rR9
va_x_r9
(va_upd_reg64 rR8
va_x_r8
(va_upd_reg64 rRsp
va_x_rsp
(va_upd_reg64 rRdi
va_x_rdi
(va_upd_reg64 rRsi
va_x_rsi
(va_upd_reg64 rRdx
va_x_rdx
(va_upd_mem va_x_mem va_s0))))))))))))
in
va_get_ok va_sM /\
(let p0_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0)
in
let p1_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0)
in
let old_p0_0:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_s0)
in
let old_p0_1:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_s0)
in
let old_p0_2:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_s0)
in
let old_p0_3:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_s0)
in
let old_p0_4:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_s0)
in
let old_p0_5:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_s0)
in
let old_p0_6:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_s0)
in
let old_p0_7:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_s0)
in
let old_p1_0:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_s0)
in
let old_p1_1:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_s0)
in
let old_p1_2:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_s0)
in
let old_p1_3:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_s0)
in
let old_p1_4:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_s0)
in
let old_p1_5:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_s0)
in
let old_p1_6:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_s0)
in
let old_p1_7:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_s0)
in
let p0_0 = Vale.X64.Decls.buffer64_read p0_b 0 (va_get_mem va_sM) in
let p0_1 = Vale.X64.Decls.buffer64_read p0_b 1 (va_get_mem va_sM) in
let p0_2 = Vale.X64.Decls.buffer64_read p0_b 2 (va_get_mem va_sM) in
let p0_3 = Vale.X64.Decls.buffer64_read p0_b 3 (va_get_mem va_sM) in
let p0_4 = Vale.X64.Decls.buffer64_read p0_b 4 (va_get_mem va_sM) in
let p0_5 = Vale.X64.Decls.buffer64_read p0_b 5 (va_get_mem va_sM) in
let p0_6 = Vale.X64.Decls.buffer64_read p0_b 6 (va_get_mem va_sM) in
let p0_7 = Vale.X64.Decls.buffer64_read p0_b 7 (va_get_mem va_sM) in
let p1_0 = Vale.X64.Decls.buffer64_read p1_b 0 (va_get_mem va_sM) in
let p1_1 = Vale.X64.Decls.buffer64_read p1_b 1 (va_get_mem va_sM) in
let p1_2 = Vale.X64.Decls.buffer64_read p1_b 2 (va_get_mem va_sM) in
let p1_3 = Vale.X64.Decls.buffer64_read p1_b 3 (va_get_mem va_sM) in
let p1_4 = Vale.X64.Decls.buffer64_read p1_b 4 (va_get_mem va_sM) in
let p1_5 = Vale.X64.Decls.buffer64_read p1_b 5 (va_get_mem va_sM) in
let p1_6 = Vale.X64.Decls.buffer64_read p1_b 6 (va_get_mem va_sM) in
let p1_7 = Vale.X64.Decls.buffer64_read p1_b 7 (va_get_mem va_sM) in
p0_0 == va_if (bit_in = 1) (fun _ -> old_p1_0) (fun _ -> old_p0_0) /\
p0_1 == va_if (bit_in = 1) (fun _ -> old_p1_1) (fun _ -> old_p0_1) /\
p0_2 == va_if (bit_in = 1) (fun _ -> old_p1_2) (fun _ -> old_p0_2) /\
p0_3 == va_if (bit_in = 1) (fun _ -> old_p1_3) (fun _ -> old_p0_3) /\
p0_4 == va_if (bit_in = 1) (fun _ -> old_p1_4) (fun _ -> old_p0_4) /\
p0_5 == va_if (bit_in = 1) (fun _ -> old_p1_5) (fun _ -> old_p0_5) /\
p0_6 == va_if (bit_in = 1) (fun _ -> old_p1_6) (fun _ -> old_p0_6) /\
p0_7 == va_if (bit_in = 1) (fun _ -> old_p1_7) (fun _ -> old_p0_7) /\
p1_0 == va_if (bit_in = 1) (fun _ -> old_p0_0) (fun _ -> old_p1_0) /\
p1_1 == va_if (bit_in = 1) (fun _ -> old_p0_1) (fun _ -> old_p1_1) /\
p1_2 == va_if (bit_in = 1) (fun _ -> old_p0_2) (fun _ -> old_p1_2) /\
p1_3 == va_if (bit_in = 1) (fun _ -> old_p0_3) (fun _ -> old_p1_3) /\
p1_4 == va_if (bit_in = 1) (fun _ -> old_p0_4) (fun _ -> old_p1_4) /\
p1_5 == va_if (bit_in = 1) (fun _ -> old_p0_5) (fun _ -> old_p1_5) /\
p1_6 == va_if (bit_in = 1) (fun _ -> old_p0_6) (fun _ -> old_p1_6) /\
p1_7 == va_if (bit_in = 1) (fun _ -> old_p0_7) (fun _ -> old_p1_7) /\
Vale.X64.Decls.modifies_buffer_2 p0_b p1_b (va_get_mem va_s0) (va_get_mem va_sM) /\
(win ==> va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\
(win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (()))) | false |
Vale.AES.GCTR_s.fst | Vale.AES.GCTR_s.gctr_encrypt_LE_def | val gctr_encrypt_LE_def (icb_BE: quad32) (plain: seq nat8) (alg: algorithm) (key: seq nat32)
: Pure (seq nat8)
(requires is_gctr_plain_LE plain /\ is_aes_key_LE alg key)
(ensures fun _ -> True) | val gctr_encrypt_LE_def (icb_BE: quad32) (plain: seq nat8) (alg: algorithm) (key: seq nat32)
: Pure (seq nat8)
(requires is_gctr_plain_LE plain /\ is_aes_key_LE alg key)
(ensures fun _ -> True) | let gctr_encrypt_LE_def (icb_BE:quad32) (plain:seq nat8) (alg:algorithm) (key:seq nat32) : Pure (seq nat8)
(requires is_gctr_plain_LE plain /\ is_aes_key_LE alg key)
(ensures fun _ -> True)
=
let num_extra = (length plain) % 16 in
if num_extra = 0 then
let plain_quads_LE = le_bytes_to_seq_quad32 plain in
let cipher_quads_LE = gctr_encrypt_recursive icb_BE plain_quads_LE alg key 0 in
le_seq_quad32_to_bytes cipher_quads_LE
else
let full_bytes_len = (length plain) - num_extra in
let full_blocks, final_block = split plain full_bytes_len in
let full_quads_LE = le_bytes_to_seq_quad32 full_blocks in
let final_quad_LE = le_bytes_to_quad32 (pad_to_128_bits final_block) in
let cipher_quads_LE = gctr_encrypt_recursive icb_BE full_quads_LE alg key 0 in
let final_cipher_quad_LE = gctr_encrypt_block icb_BE final_quad_LE alg key (full_bytes_len / 16) in
let cipher_bytes_full_LE = le_seq_quad32_to_bytes cipher_quads_LE in
let final_cipher_bytes_LE = slice (le_quad32_to_bytes final_cipher_quad_LE) 0 num_extra in
cipher_bytes_full_LE @| final_cipher_bytes_LE | {
"file_name": "vale/specs/crypto/Vale.AES.GCTR_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 49,
"end_line": 69,
"start_col": 0,
"start_line": 46
} | module Vale.AES.GCTR_s
// IMPORTANT: Following NIST's specification, this spec is written assuming a big-endian mapping from bytes to quad32s
// Since the AES spec (AES_s) is in little-endian, we need to byteswap each time we call AES
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
open Vale.AES.AES_s
open FStar.Seq
// The max length of pow2_32 corresponds to the max length of buffers in Low*
// length plain < pow2_32 <= spec max of 2**39 - 256;
let is_gctr_plain_LE (p:seq nat8) : prop0 = length p < pow2_32
type gctr_plain_LE:eqtype = p:seq nat8 { is_gctr_plain_LE p }
type gctr_plain_internal_LE:eqtype = seq quad32
let inc32 (cb:quad32) (i:int) : quad32 =
Mkfour ((cb.lo0 + i) % pow2_32) cb.lo1 cb.hi2 cb.hi3
let gctr_encrypt_block (icb_BE:quad32) (plain_LE:quad32) (alg:algorithm) (key:seq nat32) (i:int) : Pure quad32
(requires is_aes_key_LE alg key)
(ensures fun _ -> True)
=
let icb_LE = reverse_bytes_quad32 (inc32 icb_BE i) in
quad32_xor plain_LE (aes_encrypt_LE alg key icb_LE)
let rec gctr_encrypt_recursive (icb_BE:quad32) (plain:gctr_plain_internal_LE)
(alg:algorithm) (key:aes_key_LE alg) (i:int) : Tot (seq quad32) (decreases %[length plain]) =
if length plain = 0 then empty
else
cons (gctr_encrypt_block icb_BE (head plain) alg key i) (gctr_encrypt_recursive icb_BE (tail plain) alg key (i + 1))
let pad_to_128_bits (p:seq nat8) : Pure (seq nat8)
(requires True)
(ensures fun q -> length q % 16 == 0 /\ length q <= length p + 15)
=
let num_extra_bytes = length p % 16 in
if num_extra_bytes = 0 then p
else p @| (create (16 - num_extra_bytes) 0) | {
"checked_file": "/",
"dependencies": [
"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.AES.AES_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.GCTR_s.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
icb_BE: Vale.Def.Types_s.quad32 ->
plain: FStar.Seq.Base.seq Vale.Def.Types_s.nat8 ->
alg: Vale.AES.AES_common_s.algorithm ->
key: FStar.Seq.Base.seq Vale.Def.Types_s.nat32
-> Prims.Pure (FStar.Seq.Base.seq Vale.Def.Types_s.nat8) | Prims.Pure | [] | [] | [
"Vale.Def.Types_s.quad32",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat8",
"Vale.AES.AES_common_s.algorithm",
"Vale.Def.Types_s.nat32",
"Prims.op_Equality",
"Prims.int",
"Vale.Def.Types_s.le_seq_quad32_to_bytes",
"Vale.AES.GCTR_s.gctr_encrypt_recursive",
"Vale.Def.Types_s.le_bytes_to_seq_quad32",
"Prims.bool",
"FStar.Seq.Base.op_At_Bar",
"Vale.Def.Words_s.nat8",
"FStar.Seq.Base.slice",
"Vale.Def.Types_s.le_quad32_to_bytes",
"Vale.AES.GCTR_s.gctr_encrypt_block",
"Prims.op_Division",
"Vale.Def.Types_s.le_bytes_to_quad32",
"Vale.AES.GCTR_s.pad_to_128_bits",
"FStar.Pervasives.Native.tuple2",
"FStar.Seq.Properties.split",
"Prims.op_Subtraction",
"FStar.Seq.Base.length",
"Prims.op_Modulus",
"Prims.l_and",
"Vale.AES.GCTR_s.is_gctr_plain_LE",
"Vale.AES.AES_s.is_aes_key_LE",
"Prims.l_True"
] | [] | false | false | false | false | false | let gctr_encrypt_LE_def (icb_BE: quad32) (plain: seq nat8) (alg: algorithm) (key: seq nat32)
: Pure (seq nat8)
(requires is_gctr_plain_LE plain /\ is_aes_key_LE alg key)
(ensures fun _ -> True) =
| let num_extra = (length plain) % 16 in
if num_extra = 0
then
let plain_quads_LE = le_bytes_to_seq_quad32 plain in
let cipher_quads_LE = gctr_encrypt_recursive icb_BE plain_quads_LE alg key 0 in
le_seq_quad32_to_bytes cipher_quads_LE
else
let full_bytes_len = (length plain) - num_extra in
let full_blocks, final_block = split plain full_bytes_len in
let full_quads_LE = le_bytes_to_seq_quad32 full_blocks in
let final_quad_LE = le_bytes_to_quad32 (pad_to_128_bits final_block) in
let cipher_quads_LE = gctr_encrypt_recursive icb_BE full_quads_LE alg key 0 in
let final_cipher_quad_LE =
gctr_encrypt_block icb_BE final_quad_LE alg key (full_bytes_len / 16)
in
let cipher_bytes_full_LE = le_seq_quad32_to_bytes cipher_quads_LE in
let final_cipher_bytes_LE = slice (le_quad32_to_bytes final_cipher_quad_LE) 0 num_extra in
cipher_bytes_full_LE @| final_cipher_bytes_LE | false |
LowParse.Spec.SeqBytes.Base.fst | LowParse.Spec.SeqBytes.Base.parse_seq_flbytes | val parse_seq_flbytes (sz: nat)
: Tot (parser (total_constant_size_parser_kind sz) (Seq.lseq byte sz)) | val parse_seq_flbytes (sz: nat)
: Tot (parser (total_constant_size_parser_kind sz) (Seq.lseq byte sz)) | let parse_seq_flbytes
(sz: nat)
: Tot (parser (total_constant_size_parser_kind sz) (Seq.lseq byte sz))
= tot_parse_seq_flbytes sz | {
"file_name": "src/lowparse/LowParse.Spec.SeqBytes.Base.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 26,
"end_line": 18,
"start_col": 0,
"start_line": 15
} | module LowParse.Spec.SeqBytes.Base
include LowParse.Spec.FLData
let parse_seq_flbytes_gen
(sz: nat)
(s: bytes { Seq.length s == sz } )
: Tot (Seq.lseq byte sz)
= s
let tot_parse_seq_flbytes
(sz: nat)
: Tot (tot_parser (total_constant_size_parser_kind sz) (Seq.lseq byte sz))
= tot_make_total_constant_size_parser sz (Seq.lseq byte sz) (parse_seq_flbytes_gen sz) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.SeqBytes.Base.fst"
} | [
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.SeqBytes",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.SeqBytes",
"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 | sz: Prims.nat
-> LowParse.Spec.Base.parser (LowParse.Spec.Base.total_constant_size_parser_kind sz)
(FStar.Seq.Properties.lseq LowParse.Bytes.byte sz) | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"LowParse.Spec.SeqBytes.Base.tot_parse_seq_flbytes",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.total_constant_size_parser_kind",
"FStar.Seq.Properties.lseq",
"LowParse.Bytes.byte"
] | [] | false | false | false | false | false | let parse_seq_flbytes (sz: nat)
: Tot (parser (total_constant_size_parser_kind sz) (Seq.lseq byte sz)) =
| tot_parse_seq_flbytes sz | false |
LowParse.Spec.SeqBytes.Base.fst | LowParse.Spec.SeqBytes.Base.parse_seq_flbytes_gen | val parse_seq_flbytes_gen (sz: nat) (s: bytes{Seq.length s == sz}) : Tot (Seq.lseq byte sz) | val parse_seq_flbytes_gen (sz: nat) (s: bytes{Seq.length s == sz}) : Tot (Seq.lseq byte sz) | let parse_seq_flbytes_gen
(sz: nat)
(s: bytes { Seq.length s == sz } )
: Tot (Seq.lseq byte sz)
= s | {
"file_name": "src/lowparse/LowParse.Spec.SeqBytes.Base.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 8,
"start_col": 0,
"start_line": 4
} | module LowParse.Spec.SeqBytes.Base
include LowParse.Spec.FLData | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.SeqBytes.Base.fst"
} | [
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.SeqBytes",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.SeqBytes",
"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 | sz: Prims.nat -> s: LowParse.Bytes.bytes{FStar.Seq.Base.length s == sz}
-> FStar.Seq.Properties.lseq LowParse.Bytes.byte sz | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"LowParse.Bytes.bytes",
"Prims.eq2",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"FStar.Seq.Properties.lseq"
] | [] | false | false | false | false | false | let parse_seq_flbytes_gen (sz: nat) (s: bytes{Seq.length s == sz}) : Tot (Seq.lseq byte sz) =
| s | false |
LowParse.Spec.SeqBytes.Base.fst | LowParse.Spec.SeqBytes.Base.serialize_seq_flbytes' | val serialize_seq_flbytes' (sz: nat) : Tot (bare_serializer (Seq.lseq byte sz)) | val serialize_seq_flbytes' (sz: nat) : Tot (bare_serializer (Seq.lseq byte sz)) | let serialize_seq_flbytes'
(sz: nat)
: Tot (bare_serializer (Seq.lseq byte sz))
= fun (x: Seq.lseq byte sz) -> (
x
) | {
"file_name": "src/lowparse/LowParse.Spec.SeqBytes.Base.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 25,
"start_col": 0,
"start_line": 20
} | module LowParse.Spec.SeqBytes.Base
include LowParse.Spec.FLData
let parse_seq_flbytes_gen
(sz: nat)
(s: bytes { Seq.length s == sz } )
: Tot (Seq.lseq byte sz)
= s
let tot_parse_seq_flbytes
(sz: nat)
: Tot (tot_parser (total_constant_size_parser_kind sz) (Seq.lseq byte sz))
= tot_make_total_constant_size_parser sz (Seq.lseq byte sz) (parse_seq_flbytes_gen sz)
let parse_seq_flbytes
(sz: nat)
: Tot (parser (total_constant_size_parser_kind sz) (Seq.lseq byte sz))
= tot_parse_seq_flbytes sz | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.SeqBytes.Base.fst"
} | [
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.SeqBytes",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.SeqBytes",
"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 | sz: Prims.nat
-> LowParse.Spec.Base.bare_serializer (FStar.Seq.Properties.lseq LowParse.Bytes.byte sz) | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"FStar.Seq.Properties.lseq",
"LowParse.Bytes.byte",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.bare_serializer"
] | [] | false | false | false | false | false | let serialize_seq_flbytes' (sz: nat) : Tot (bare_serializer (Seq.lseq byte sz)) =
| fun (x: Seq.lseq byte sz) -> (x) | false |
Hacl.P256.PrecompTable.fst | Hacl.P256.PrecompTable.precomp_g_pow2_64_table_w4 | val precomp_g_pow2_64_table_w4:
x:glbuffer uint64 192ul{witnessed x precomp_g_pow2_64_table_lseq_w4 /\ recallable x} | val precomp_g_pow2_64_table_w4:
x:glbuffer uint64 192ul{witnessed x precomp_g_pow2_64_table_lseq_w4 /\ recallable x} | let precomp_g_pow2_64_table_w4:
x:glbuffer uint64 192ul{witnessed x precomp_g_pow2_64_table_lseq_w4 /\ recallable x} =
createL_global precomp_g_pow2_64_table_list_w4 | {
"file_name": "code/ecdsap256/Hacl.P256.PrecompTable.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 234,
"start_col": 0,
"start_line": 232
} | module Hacl.P256.PrecompTable
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module SPT = Hacl.Spec.PrecompBaseTable
module SPT256 = Hacl.Spec.PrecompBaseTable256
module SPTK = Hacl.Spec.P256.PrecompTable
module S = Spec.P256
module SL = Spec.P256.Lemmas
open Hacl.Impl.P256.Point
include Hacl.Impl.P256.Group
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let proj_point_to_list p =
SPTK.proj_point_to_list_lemma p;
SPTK.proj_point_to_list p
let lemma_refl x =
SPTK.proj_point_to_list_lemma x
//-----------------
inline_for_extraction noextract
let proj_g_pow2_64 : S.proj_point =
[@inline_let]
let rX : S.felem = 0x000931f4ae428a4ad81ee0aa89cf5247ce85d4dd696c61b4bb9d4761e57b7fbe in
[@inline_let]
let rY : S.felem = 0x7e88e5e6a142d5c2269f21a158e82ab2c79fcecb26e397b96fd5b9fbcd0a69a5 in
[@inline_let]
let rZ : S.felem = 0x02626dc2dd5e06cd19de5e6afb6c5dbdd3e41dc1472e7b8ef11eb0662e41c44b in
(rX, rY, rZ)
val lemma_proj_g_pow2_64_eval : unit ->
Lemma (SE.exp_pow2 S.mk_p256_concrete_ops S.base_point 64 == proj_g_pow2_64)
let lemma_proj_g_pow2_64_eval () =
SPT256.exp_pow2_rec_is_exp_pow2 S.mk_p256_concrete_ops S.base_point 64;
let qX, qY, qZ = normalize_term (SPT256.exp_pow2_rec S.mk_p256_concrete_ops S.base_point 64) in
normalize_term_spec (SPT256.exp_pow2_rec S.mk_p256_concrete_ops S.base_point 64);
let rX : S.felem = 0x000931f4ae428a4ad81ee0aa89cf5247ce85d4dd696c61b4bb9d4761e57b7fbe in
let rY : S.felem = 0x7e88e5e6a142d5c2269f21a158e82ab2c79fcecb26e397b96fd5b9fbcd0a69a5 in
let rZ : S.felem = 0x02626dc2dd5e06cd19de5e6afb6c5dbdd3e41dc1472e7b8ef11eb0662e41c44b in
assert_norm (qX == rX /\ qY == rY /\ qZ == rZ)
inline_for_extraction noextract
let proj_g_pow2_128 : S.proj_point =
[@inline_let]
let rX : S.felem = 0x04c3aaf6c6c00704e96eda89461d63fd2c97ee1e6786fc785e6afac7aa92f9b1 in
[@inline_let]
let rY : S.felem = 0x14f1edaeb8e9c8d4797d164a3946c7ff50a7c8cd59139a4dbce354e6e4df09c3 in
[@inline_let]
let rZ : S.felem = 0x80119ced9a5ce83c4e31f8de1a38f89d5f9ff9f637dca86d116a4217f83e55d2 in
(rX, rY, rZ)
val lemma_proj_g_pow2_128_eval : unit ->
Lemma (SE.exp_pow2 S.mk_p256_concrete_ops proj_g_pow2_64 64 == proj_g_pow2_128)
let lemma_proj_g_pow2_128_eval () =
SPT256.exp_pow2_rec_is_exp_pow2 S.mk_p256_concrete_ops proj_g_pow2_64 64;
let qX, qY, qZ = normalize_term (SPT256.exp_pow2_rec S.mk_p256_concrete_ops proj_g_pow2_64 64) in
normalize_term_spec (SPT256.exp_pow2_rec S.mk_p256_concrete_ops proj_g_pow2_64 64);
let rX : S.felem = 0x04c3aaf6c6c00704e96eda89461d63fd2c97ee1e6786fc785e6afac7aa92f9b1 in
let rY : S.felem = 0x14f1edaeb8e9c8d4797d164a3946c7ff50a7c8cd59139a4dbce354e6e4df09c3 in
let rZ : S.felem = 0x80119ced9a5ce83c4e31f8de1a38f89d5f9ff9f637dca86d116a4217f83e55d2 in
assert_norm (qX == rX /\ qY == rY /\ qZ == rZ)
inline_for_extraction noextract
let proj_g_pow2_192 : S.proj_point =
[@inline_let]
let rX : S.felem = 0xc762a9c8ae1b2f7434ff8da70fe105e0d4f188594989f193de0dbdbf5f60cb9a in
[@inline_let]
let rY : S.felem = 0x1eddaf51836859e1369f1ae8d9ab02e4123b6f151d9b796e297a38fa5613d9bc in
[@inline_let]
let rZ : S.felem = 0xcb433ab3f67815707e398dc7910cc4ec6ea115360060fc73c35b53dce02e2c72 in
(rX, rY, rZ)
val lemma_proj_g_pow2_192_eval : unit ->
Lemma (SE.exp_pow2 S.mk_p256_concrete_ops proj_g_pow2_128 64 == proj_g_pow2_192)
let lemma_proj_g_pow2_192_eval () =
SPT256.exp_pow2_rec_is_exp_pow2 S.mk_p256_concrete_ops proj_g_pow2_128 64;
let qX, qY, qZ = normalize_term (SPT256.exp_pow2_rec S.mk_p256_concrete_ops proj_g_pow2_128 64) in
normalize_term_spec (SPT256.exp_pow2_rec S.mk_p256_concrete_ops proj_g_pow2_128 64);
let rX : S.felem = 0xc762a9c8ae1b2f7434ff8da70fe105e0d4f188594989f193de0dbdbf5f60cb9a in
let rY : S.felem = 0x1eddaf51836859e1369f1ae8d9ab02e4123b6f151d9b796e297a38fa5613d9bc in
let rZ : S.felem = 0xcb433ab3f67815707e398dc7910cc4ec6ea115360060fc73c35b53dce02e2c72 in
assert_norm (qX == rX /\ qY == rY /\ qZ == rZ)
// let proj_g_pow2_64 : S.proj_point =
// normalize_term (SPT256.exp_pow2_rec S.mk_p256_concrete_ops S.base_point 64)
// let proj_g_pow2_128 : S.proj_point =
// normalize_term (SPT256.exp_pow2_rec S.mk_p256_concrete_ops proj_g_pow2_64 64)
// let proj_g_pow2_192 : S.proj_point =
// normalize_term (SPT256.exp_pow2_rec S.mk_p256_concrete_ops proj_g_pow2_128 64)
inline_for_extraction noextract
let proj_g_pow2_64_list : SPTK.point_list =
normalize_term (SPTK.proj_point_to_list proj_g_pow2_64)
inline_for_extraction noextract
let proj_g_pow2_128_list : SPTK.point_list =
normalize_term (SPTK.proj_point_to_list proj_g_pow2_128)
inline_for_extraction noextract
let proj_g_pow2_192_list : SPTK.point_list =
normalize_term (SPTK.proj_point_to_list proj_g_pow2_192)
let proj_g_pow2_64_lseq : LSeq.lseq uint64 12 =
normalize_term_spec (SPTK.proj_point_to_list proj_g_pow2_64);
Seq.seq_of_list proj_g_pow2_64_list
let proj_g_pow2_128_lseq : LSeq.lseq uint64 12 =
normalize_term_spec (SPTK.proj_point_to_list proj_g_pow2_128);
Seq.seq_of_list proj_g_pow2_128_list
let proj_g_pow2_192_lseq : LSeq.lseq uint64 12 =
normalize_term_spec (SPTK.proj_point_to_list proj_g_pow2_192);
Seq.seq_of_list proj_g_pow2_192_list
val proj_g_pow2_64_lemma: unit ->
Lemma (S.to_aff_point proj_g_pow2_64 == pow_point (pow2 64) g_aff)
let proj_g_pow2_64_lemma () =
lemma_proj_g_pow2_64_eval ();
SPT256.a_pow2_64_lemma S.mk_p256_concrete_ops S.base_point
val proj_g_pow2_128_lemma: unit ->
Lemma (S.to_aff_point proj_g_pow2_128 == pow_point (pow2 128) g_aff)
let proj_g_pow2_128_lemma () =
lemma_proj_g_pow2_128_eval ();
lemma_proj_g_pow2_64_eval ();
SPT256.a_pow2_128_lemma S.mk_p256_concrete_ops S.base_point
val proj_g_pow2_192_lemma: unit ->
Lemma (S.to_aff_point proj_g_pow2_192 == pow_point (pow2 192) g_aff)
let proj_g_pow2_192_lemma () =
lemma_proj_g_pow2_192_eval ();
lemma_proj_g_pow2_128_eval ();
lemma_proj_g_pow2_64_eval ();
SPT256.a_pow2_192_lemma S.mk_p256_concrete_ops S.base_point
let proj_g_pow2_64_lseq_lemma () =
normalize_term_spec (SPTK.proj_point_to_list proj_g_pow2_64);
proj_g_pow2_64_lemma ();
SPTK.proj_point_to_list_lemma proj_g_pow2_64
let proj_g_pow2_128_lseq_lemma () =
normalize_term_spec (SPTK.proj_point_to_list proj_g_pow2_128);
proj_g_pow2_128_lemma ();
SPTK.proj_point_to_list_lemma proj_g_pow2_128
let proj_g_pow2_192_lseq_lemma () =
normalize_term_spec (SPTK.proj_point_to_list proj_g_pow2_192);
proj_g_pow2_192_lemma ();
SPTK.proj_point_to_list_lemma proj_g_pow2_192
let mk_proj_g_pow2_64 () =
createL proj_g_pow2_64_list
let mk_proj_g_pow2_128 () =
createL proj_g_pow2_128_list
let mk_proj_g_pow2_192 () =
createL proj_g_pow2_192_list
//----------------
/// window size = 4; precomputed table = [[0]G, [1]G, ..., [15]G]
inline_for_extraction noextract
let precomp_basepoint_table_list_w4: x:list uint64{FStar.List.Tot.length x = 192} =
normalize_term (SPT.precomp_base_table_list mk_p256_precomp_base_table S.base_point 15)
let precomp_basepoint_table_lseq_w4 : LSeq.lseq uint64 192 =
normalize_term_spec (SPT.precomp_base_table_list mk_p256_precomp_base_table S.base_point 15);
Seq.seq_of_list precomp_basepoint_table_list_w4
let precomp_basepoint_table_lemma_w4 () =
normalize_term_spec (SPT.precomp_base_table_list mk_p256_precomp_base_table S.base_point 15);
SPT.precomp_base_table_lemma mk_p256_precomp_base_table S.base_point 16 precomp_basepoint_table_lseq_w4
let precomp_basepoint_table_w4:
x:glbuffer uint64 192ul{witnessed x precomp_basepoint_table_lseq_w4 /\ recallable x} =
createL_global precomp_basepoint_table_list_w4
/// window size = 4; precomputed table = [[0]([pow2 64]G), [1]([pow2 64]G), ..., [15]([pow2 64]G)]
inline_for_extraction noextract
let precomp_g_pow2_64_table_list_w4: x:list uint64{FStar.List.Tot.length x = 192} =
normalize_term (SPT.precomp_base_table_list mk_p256_precomp_base_table proj_g_pow2_64 15)
let precomp_g_pow2_64_table_lseq_w4 : LSeq.lseq uint64 192 =
normalize_term_spec (SPT.precomp_base_table_list mk_p256_precomp_base_table proj_g_pow2_64 15);
Seq.seq_of_list precomp_g_pow2_64_table_list_w4
let precomp_g_pow2_64_table_lemma_w4 () =
normalize_term_spec (SPT.precomp_base_table_list mk_p256_precomp_base_table proj_g_pow2_64 15);
SPT.precomp_base_table_lemma mk_p256_precomp_base_table
proj_g_pow2_64 16 precomp_g_pow2_64_table_lseq_w4;
proj_g_pow2_64_lemma () | {
"checked_file": "/",
"dependencies": [
"Spec.P256.Lemmas.fsti.checked",
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable256.fsti.checked",
"Hacl.Spec.PrecompBaseTable.fsti.checked",
"Hacl.Spec.P256.PrecompTable.fsti.checked",
"Hacl.Impl.P256.Point.fsti.checked",
"Hacl.Impl.P256.Group.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.P256.PrecompTable.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.PrecompTable",
"short_module": "SPTK"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation.Definitions",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation.Definition",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.P256",
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x:
Lib.Buffer.glbuffer Lib.IntTypes.uint64 192ul
{ Lib.Buffer.witnessed x Hacl.P256.PrecompTable.precomp_g_pow2_64_table_lseq_w4 /\
Lib.Buffer.recallable x } | Prims.Tot | [
"total"
] | [] | [
"Lib.Buffer.createL_global",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Hacl.P256.PrecompTable.precomp_g_pow2_64_table_list_w4",
"Lib.Buffer.glbuffer",
"Lib.IntTypes.size",
"FStar.Pervasives.normalize_term",
"Lib.IntTypes.size_nat",
"FStar.List.Tot.Base.length",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Prims.l_and",
"Lib.Buffer.witnessed",
"Hacl.P256.PrecompTable.precomp_g_pow2_64_table_lseq_w4",
"Lib.Buffer.recallable",
"Lib.Buffer.CONST"
] | [] | false | false | false | false | false | let precomp_g_pow2_64_table_w4:x:
glbuffer uint64 192ul {witnessed x precomp_g_pow2_64_table_lseq_w4 /\ recallable x} =
| createL_global precomp_g_pow2_64_table_list_w4 | false |
Hacl.HMAC.fst | Hacl.HMAC.wrap_key_st | val wrap_key_st : a: Spec.Hash.Definitions.fixed_len_alg -> Type0 | let wrap_key_st (a: fixed_len_alg) =
output: B.buffer uint8 { B.length output == block_length a } ->
key: B.buffer uint8 {B.length key `less_than_max_input_length` a /\ B.disjoint output key} ->
len: UInt32.t {v len = B.length key} ->
Stack unit
(requires fun h0 ->
B.live h0 output /\ B.live h0 key /\
B.as_seq h0 output == Seq.create (block_length a) (u8 0))
(ensures fun h0 _ h1 ->
B.(modifies (loc_buffer output) h0 h1) /\
B.as_seq h1 output == wrap a (B.as_seq h0 key)) | {
"file_name": "code/hmac/Hacl.HMAC.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 53,
"end_line": 56,
"start_col": 0,
"start_line": 46
} | module Hacl.HMAC
module S = FStar.Seq
module D = Hacl.Hash.Definitions
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module MB = LowStar.Monotonic.Buffer
module C = Hacl.Impl.Blake2.Core
open FStar.HyperStack.ST
open LowStar.BufferOps
open Spec.Hash.Definitions
open Spec.Agile.HMAC
open Spec.Agile.Hash
open Spec.Hash.Incremental
open Spec.Hash.Incremental.Definitions
open Spec.Hash.Lemmas
friend Spec.Agile.HMAC
friend Spec.Agile.Hash
let _: squash (inversion hash_alg) = allow_inversion hash_alg
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50"
/// Helpers
inline_for_extraction
val xor_bytes_inplace:
a: B.buffer uint8 ->
b: B.buffer uint8 ->
len: UInt32.t {v len = B.length a /\ v len = B.length b} ->
Stack unit
(requires fun h0 -> B.disjoint a b /\ B.live h0 a /\ B.live h0 b)
(ensures fun h0 _ h1 ->
B.(modifies (loc_buffer a) h0 h1) /\
B.as_seq h1 a == Spec.Loops.seq_map2 ( ^. ) (B.as_seq h0 a) (B.as_seq h0 b))
inline_for_extraction
let xor_bytes_inplace a b len =
C.Loops.in_place_map2 a b len ( ^. )
/// Agile implementation
// we rely on the output being zero-initialized for the correctness of padding | {
"checked_file": "/",
"dependencies": [
"Spec.Loops.fst.checked",
"Spec.Hash.Lemmas.fsti.checked",
"Spec.Hash.Incremental.Definitions.fst.checked",
"Spec.Hash.Incremental.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fst.checked",
"Spec.Agile.HMAC.fst.checked",
"Spec.Agile.Hash.fst.checked",
"Spec.Agile.Hash.fst.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Hacl.Streaming.SHA2.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Hash.SHA2.fsti.checked",
"Hacl.Hash.SHA1.fsti.checked",
"Hacl.Hash.Definitions.fst.checked",
"Hacl.Hash.Blake2s_32.fsti.checked",
"Hacl.Hash.Blake2b_32.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt128.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Int.Cast.Full.fst.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Calc.fsti.checked",
"C.Loops.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.HMAC.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Hash.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Incremental.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Incremental",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.HMAC",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Blake2.Core",
"short_module": "C"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "MB"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Hash.Definitions",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.HMAC",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Hash.Definitions",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"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: Spec.Hash.Definitions.fixed_len_alg -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Spec.Hash.Definitions.fixed_len_alg",
"LowStar.Buffer.buffer",
"Lib.IntTypes.uint8",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.op_disEquality",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"Spec.Hash.Definitions.block_length",
"Prims.l_and",
"Spec.Hash.Definitions.less_than_max_input_length",
"LowStar.Monotonic.Buffer.disjoint",
"FStar.UInt32.t",
"Prims.op_Equality",
"Lib.IntTypes.range",
"Lib.IntTypes.U32",
"Lib.IntTypes.v",
"Lib.IntTypes.PUB",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.live",
"FStar.Seq.Base.seq",
"LowStar.Monotonic.Buffer.as_seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.u8",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_buffer",
"Spec.Agile.HMAC.wrap"
] | [] | false | false | false | true | true | let wrap_key_st (a: fixed_len_alg) =
|
output: B.buffer uint8 {B.length output == block_length a} ->
key: B.buffer uint8 {(B.length key) `less_than_max_input_length` a /\ B.disjoint output key} ->
len: UInt32.t{v len = B.length key}
-> Stack unit
(requires
fun h0 ->
B.live h0 output /\ B.live h0 key /\
B.as_seq h0 output == Seq.create (block_length a) (u8 0))
(ensures
fun h0 _ h1 ->
B.(modifies (loc_buffer output) h0 h1) /\ B.as_seq h1 output == wrap a (B.as_seq h0 key)) | false |
|
LowParse.Spec.SeqBytes.Base.fst | LowParse.Spec.SeqBytes.Base.tot_parse_seq_flbytes | val tot_parse_seq_flbytes (sz: nat)
: Tot (tot_parser (total_constant_size_parser_kind sz) (Seq.lseq byte sz)) | val tot_parse_seq_flbytes (sz: nat)
: Tot (tot_parser (total_constant_size_parser_kind sz) (Seq.lseq byte sz)) | let tot_parse_seq_flbytes
(sz: nat)
: Tot (tot_parser (total_constant_size_parser_kind sz) (Seq.lseq byte sz))
= tot_make_total_constant_size_parser sz (Seq.lseq byte sz) (parse_seq_flbytes_gen sz) | {
"file_name": "src/lowparse/LowParse.Spec.SeqBytes.Base.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 86,
"end_line": 13,
"start_col": 0,
"start_line": 10
} | module LowParse.Spec.SeqBytes.Base
include LowParse.Spec.FLData
let parse_seq_flbytes_gen
(sz: nat)
(s: bytes { Seq.length s == sz } )
: Tot (Seq.lseq byte sz)
= s | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.SeqBytes.Base.fst"
} | [
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.SeqBytes",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.SeqBytes",
"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 | sz: Prims.nat
-> LowParse.Spec.Base.tot_parser (LowParse.Spec.Base.total_constant_size_parser_kind sz)
(FStar.Seq.Properties.lseq LowParse.Bytes.byte sz) | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"LowParse.Spec.Combinators.tot_make_total_constant_size_parser",
"FStar.Seq.Properties.lseq",
"LowParse.Bytes.byte",
"LowParse.Spec.SeqBytes.Base.parse_seq_flbytes_gen",
"LowParse.Spec.Base.tot_parser",
"LowParse.Spec.Base.total_constant_size_parser_kind"
] | [] | false | false | false | false | false | let tot_parse_seq_flbytes (sz: nat)
: Tot (tot_parser (total_constant_size_parser_kind sz) (Seq.lseq byte sz)) =
| tot_make_total_constant_size_parser sz (Seq.lseq byte sz) (parse_seq_flbytes_gen sz) | false |
LowParse.Spec.SeqBytes.Base.fst | LowParse.Spec.SeqBytes.Base.serialize_seq_flbytes | val serialize_seq_flbytes (sz: nat) : Tot (serializer (parse_seq_flbytes sz)) | val serialize_seq_flbytes (sz: nat) : Tot (serializer (parse_seq_flbytes sz)) | let serialize_seq_flbytes
(sz: nat)
: Tot (serializer (parse_seq_flbytes sz))
= serialize_seq_flbytes_correct sz;
serialize_seq_flbytes' sz | {
"file_name": "src/lowparse/LowParse.Spec.SeqBytes.Base.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 27,
"end_line": 47,
"start_col": 0,
"start_line": 43
} | module LowParse.Spec.SeqBytes.Base
include LowParse.Spec.FLData
let parse_seq_flbytes_gen
(sz: nat)
(s: bytes { Seq.length s == sz } )
: Tot (Seq.lseq byte sz)
= s
let tot_parse_seq_flbytes
(sz: nat)
: Tot (tot_parser (total_constant_size_parser_kind sz) (Seq.lseq byte sz))
= tot_make_total_constant_size_parser sz (Seq.lseq byte sz) (parse_seq_flbytes_gen sz)
let parse_seq_flbytes
(sz: nat)
: Tot (parser (total_constant_size_parser_kind sz) (Seq.lseq byte sz))
= tot_parse_seq_flbytes sz
let serialize_seq_flbytes'
(sz: nat)
: Tot (bare_serializer (Seq.lseq byte sz))
= fun (x: Seq.lseq byte sz) -> (
x
)
let serialize_seq_flbytes_correct
(sz: nat)
: Lemma
(serializer_correct (parse_seq_flbytes sz) (serialize_seq_flbytes' sz))
= let prf
(input: Seq.lseq byte sz)
: Lemma
(
let ser = serialize_seq_flbytes' sz input in
Seq.length ser == sz /\
parse (parse_seq_flbytes sz) ser == Some (input, sz)
)
= ()
in
Classical.forall_intro prf | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.SeqBytes.Base.fst"
} | [
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.SeqBytes",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.SeqBytes",
"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 | sz: Prims.nat -> LowParse.Spec.Base.serializer (LowParse.Spec.SeqBytes.Base.parse_seq_flbytes sz) | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"LowParse.Spec.SeqBytes.Base.serialize_seq_flbytes'",
"Prims.unit",
"LowParse.Spec.SeqBytes.Base.serialize_seq_flbytes_correct",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.Base.total_constant_size_parser_kind",
"FStar.Seq.Properties.lseq",
"LowParse.Bytes.byte",
"LowParse.Spec.SeqBytes.Base.parse_seq_flbytes"
] | [] | false | false | false | false | false | let serialize_seq_flbytes (sz: nat) : Tot (serializer (parse_seq_flbytes sz)) =
| serialize_seq_flbytes_correct sz;
serialize_seq_flbytes' sz | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.