effect
stringclasses 48
values | original_source_type
stringlengths 0
23k
| opens_and_abbrevs
listlengths 2
92
| isa_cross_project_example
bool 1
class | source_definition
stringlengths 9
57.9k
| partial_definition
stringlengths 7
23.3k
| is_div
bool 2
classes | is_type
null | is_proof
bool 2
classes | completed_definiton
stringlengths 1
250k
| dependencies
dict | effect_flags
sequencelengths 0
2
| ideal_premises
sequencelengths 0
236
| mutual_with
sequencelengths 0
11
| file_context
stringlengths 0
407k
| interleaved
bool 1
class | is_simply_typed
bool 2
classes | file_name
stringlengths 5
48
| vconfig
dict | is_simple_lemma
null | source_type
stringlengths 10
23k
| proof_features
sequencelengths 0
1
| name
stringlengths 8
95
| source
dict | verbose_type
stringlengths 1
7.42k
| source_range
dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Prims.Tot | val repr (a:Type u#a)
(already_framed:bool)
(opened_invariants:inames)
(g:observability)
(pre:pre_t)
(post:post_t a)
(req:req_t pre)
(ens:ens_t pre a post)
: Type u#(max a 2) | [
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens) | val repr (a:Type u#a)
(already_framed:bool)
(opened_invariants:inames)
(g:observability)
(pre:pre_t)
(post:post_t a)
(req:req_t pre)
(ens:ens_t pre a post)
: Type u#(max a 2)
let repr a framed opened f pre post req ens = | false | null | false | action_except_full a opened (hp_of pre) (to_post post) (req_to_act_req req) (ens_to_act_ens ens) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Prims.bool",
"Steel.Memory.inames",
"Steel.Effect.Common.observability",
"Steel.Effect.Common.pre_t",
"Steel.Effect.Common.post_t",
"Steel.Effect.Common.req_t",
"Steel.Effect.Common.ens_t",
"Steel.Memory.action_except_full",
"Steel.Effect.Common.hp_of",
"Steel.Effect.Atomic.to_post",
"Steel.Effect.Atomic.req_to_act_req",
"Steel.Effect.Atomic.ens_to_act_ens"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val repr (a:Type u#a)
(already_framed:bool)
(opened_invariants:inames)
(g:observability)
(pre:pre_t)
(post:post_t a)
(req:req_t pre)
(ens:ens_t pre a post)
: Type u#(max a 2) | [] | Steel.Effect.Atomic.repr | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
a: Type ->
already_framed: Prims.bool ->
opened_invariants: Steel.Memory.inames ->
g: Steel.Effect.Common.observability ->
pre: Steel.Effect.Common.pre_t ->
post: Steel.Effect.Common.post_t a ->
req: Steel.Effect.Common.req_t pre ->
ens: Steel.Effect.Common.ens_t pre a post
-> Type | {
"end_col": 45,
"end_line": 42,
"start_col": 2,
"start_line": 41
} |
Prims.Tot | val lift_ghost_atomic
(a:Type)
(opened:inames)
(#framed:eqtype_as_type bool)
(#[@@@ framing_implicit] pre:pre_t) (#[@@@ framing_implicit] post:post_t a)
(#[@@@ framing_implicit] req:req_t pre) (#[@@@ framing_implicit] ens:ens_t pre a post)
(f:repr a framed opened Unobservable pre post req ens)
: repr a framed opened Unobservable pre post req ens | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lift_ghost_atomic a o f = f | val lift_ghost_atomic
(a:Type)
(opened:inames)
(#framed:eqtype_as_type bool)
(#[@@@ framing_implicit] pre:pre_t) (#[@@@ framing_implicit] post:post_t a)
(#[@@@ framing_implicit] req:req_t pre) (#[@@@ framing_implicit] ens:ens_t pre a post)
(f:repr a framed opened Unobservable pre post req ens)
: repr a framed opened Unobservable pre post req ens
let lift_ghost_atomic a o f = | false | null | false | f | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Memory.inames",
"FStar.Pervasives.eqtype_as_type",
"Prims.bool",
"Steel.Effect.Common.pre_t",
"Steel.Effect.Common.post_t",
"Steel.Effect.Common.req_t",
"Steel.Effect.Common.ens_t",
"Steel.Effect.Atomic.repr",
"Steel.Effect.Common.Unobservable"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lift_ghost_atomic
(a:Type)
(opened:inames)
(#framed:eqtype_as_type bool)
(#[@@@ framing_implicit] pre:pre_t) (#[@@@ framing_implicit] post:post_t a)
(#[@@@ framing_implicit] req:req_t pre) (#[@@@ framing_implicit] ens:ens_t pre a post)
(f:repr a framed opened Unobservable pre post req ens)
: repr a framed opened Unobservable pre post req ens | [] | Steel.Effect.Atomic.lift_ghost_atomic | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
a: Type ->
opened: Steel.Memory.inames ->
f: Steel.Effect.Atomic.repr a framed opened Steel.Effect.Common.Unobservable pre post req ens
-> Steel.Effect.Atomic.repr a framed opened Steel.Effect.Common.Unobservable pre post req ens | {
"end_col": 31,
"end_line": 351,
"start_col": 30,
"start_line": 351
} |
Prims.Tot | val mk_selector_vprop_hp
(#t: Type0) (p: t -> vprop)
: Tot (slprop u#1) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mk_selector_vprop_hp
p
= Steel.Memory.h_exists (hp_of_pointwise p) | val mk_selector_vprop_hp
(#t: Type0) (p: t -> vprop)
: Tot (slprop u#1)
let mk_selector_vprop_hp p = | false | null | false | Steel.Memory.h_exists (hp_of_pointwise p) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Effect.Common.vprop",
"Steel.Memory.h_exists",
"Steel.Effect.Atomic.hp_of_pointwise",
"Steel.Memory.slprop"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p)
let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m)
let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m)
let witness_exists #a #u #p _ =
SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x)))
let lift_exists #a #u p =
as_atomic_action_ghost (Steel.Memory.lift_h_exists #u (fun x -> hp_of (p x)))
let exists_equiv p q =
Classical.forall_intro_2 reveal_equiv;
h_exists_cong (h_exists_sl' p) (h_exists_sl' q)
let exists_cong p q =
rewrite_slprop (h_exists p) (h_exists q)
(fun m ->
reveal_equiv (h_exists p) (h_exists q);
exists_equiv p q)
let fresh_invariant #uses p ctxt =
rewrite_slprop p (to_vprop (hp_of p)) (fun _ -> ());
let i = as_atomic_unobservable_action (fresh_invariant uses (hp_of p) ctxt) in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ());
return i
let new_invariant #uses p = let i = fresh_invariant #uses p [] in return i
(*
* AR: SteelAtomic and SteelGhost are not marked reifiable since we intend to run Steel programs natively
* However to implement the with_inv combinators we need to reify their thunks to reprs
* We could implement it better by having support for reification only in the .fst file
* But for now assuming a function
*)
assume val reify_steel_atomic_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames) (#g:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelAtomicBase a framed opened_invariants g pre post req ens)
: repr a framed opened_invariants g pre post req ens
[@@warn_on_use "as_unobservable_atomic_action is a trusted primitive"]
let as_atomic_o_action
(#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(o:observability)
(f:action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x))
= SteelAtomicBaseT?.reflect f
let with_invariant #a #fp #fp' #obs #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x = as_atomic_o_action obs
(Steel.Memory.with_invariant
#a
#(hp_of fp)
#(fun x -> hp_of (fp' x))
#opened
#(hp_of p)
i
(reify_steel_atomic_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return x
assume val reify_steel_ghost_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelGhostBase a framed opened_invariants Unobservable pre post req ens)
: repr a framed opened_invariants Unobservable pre post req ens
let with_invariant_g #a #fp #fp' #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x =
as_atomic_unobservable_action
(Steel.Memory.with_invariant #a #(hp_of fp) #(fun x -> hp_of (fp' x)) #opened #(hp_of p) i (reify_steel_ghost_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return (hide x)
let intro_vrefine v p =
let m = get () in
let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased (vrefine_t v p) = Ghost.hide (Ghost.reveal x) in
change_slprop
v
(vrefine v p)
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let elim_vrefine v p =
let h = get() in
let x : Ghost.erased (vrefine_t v p) = gget (vrefine v p) in
let x' : Ghost.erased (t_of v) = Ghost.hide (Ghost.reveal x) in
change_slprop
(vrefine v p)
v
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let vdep_cond
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
: Tot prop
= q == p (fst x1)
let vdep_rel
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
(x2: (t_of (vdep v p)))
: Tot prop
=
q == p (fst x1) /\
dfst (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == fst x1 /\
dsnd (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == snd x1
let intro_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (v `star` q)) m /\
q == p (fst (sel_of (v `star` q) m))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
))
=
Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m
let intro_vdep
v q p
=
reveal_star v q;
change_slprop_rel_with_cond
(v `star` q)
(vdep v p)
(vdep_cond v q p)
(vdep_rel v q p)
(fun m -> intro_vdep_lemma v q p m)
let vdep_cond_recip
(v: vprop)
(p: (t_of v -> Tot vprop))
(q: vprop)
(x2: t_of (vdep v p))
: Tot prop
= q == p (dfst (x2 <: dtuple2 (t_of v) (vdep_payload v p)))
let vdep_rel_recip
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x2: (t_of (vdep v p)))
(x1: t_of (v `star` q))
: Tot prop
=
vdep_rel v q p x1 x2
let elim_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (vdep v p)) m /\
q == p (dfst (sel_of (vdep v p) m <: dtuple2 (t_of v) (vdep_payload v p)))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
))
=
Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m
let elim_vdep0
(#opened:inames)
(v: vprop)
(p: (t_of v -> Tot vprop))
(q: vprop)
: SteelGhost unit opened
(vdep v p)
(fun _ -> v `star` q)
(requires (fun h -> q == p (dfst (h (vdep v p)))))
(ensures (fun h _ h' ->
let fs = h' v in
let sn = h' q in
let x2 = h (vdep v p) in
q == p fs /\
dfst x2 == fs /\
dsnd x2 == sn
))
= change_slprop_rel_with_cond
(vdep v p)
(v `star` q)
(vdep_cond_recip v p q)
(vdep_rel_recip v q p)
(fun m -> elim_vdep_lemma v q p m);
reveal_star v q
let elim_vdep
v p
= let r = gget (vdep v p) in
let res = Ghost.hide (dfst #(t_of v) #(vdep_payload v p) (Ghost.reveal r)) in
elim_vdep0 v p (p (Ghost.reveal res));
res
let intro_vrewrite
v #t f
= let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased t = Ghost.hide (f (Ghost.reveal x)) in
change_slprop
v
(vrewrite v f)
x
x'
(fun m ->
vrewrite_sel_eq v f m
)
let elim_vrewrite
v #t f
=
change_slprop_rel
(vrewrite v f)
v
(fun y x -> y == f x)
(fun m -> vrewrite_sel_eq v f m)
/// Deriving a selector-style vprop from an injective pts-to-style vprop
let hp_of_pointwise
(#t: Type)
(p: t -> vprop)
(x: t)
: Tot slprop
= hp_of (p x)
let mk_selector_vprop_hp | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mk_selector_vprop_hp
(#t: Type0) (p: t -> vprop)
: Tot (slprop u#1) | [] | Steel.Effect.Atomic.mk_selector_vprop_hp | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: (_: t -> Steel.Effect.Common.vprop) -> Steel.Memory.slprop | {
"end_col": 43,
"end_line": 875,
"start_col": 2,
"start_line": 875
} |
Prims.Tot | val vdep_cond (v q: vprop) (p: (t_of v -> Tot vprop)) (x1: t_of (v `star` q)) : Tot prop | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let vdep_cond
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
: Tot prop
= q == p (fst x1) | val vdep_cond (v q: vprop) (p: (t_of v -> Tot vprop)) (x1: t_of (v `star` q)) : Tot prop
let vdep_cond (v q: vprop) (p: (t_of v -> Tot vprop)) (x1: t_of (v `star` q)) : Tot prop = | false | null | false | q == p (fst x1) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.t_of",
"Steel.Effect.Common.star",
"Prims.eq2",
"FStar.Pervasives.Native.fst",
"Prims.prop"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p)
let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m)
let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m)
let witness_exists #a #u #p _ =
SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x)))
let lift_exists #a #u p =
as_atomic_action_ghost (Steel.Memory.lift_h_exists #u (fun x -> hp_of (p x)))
let exists_equiv p q =
Classical.forall_intro_2 reveal_equiv;
h_exists_cong (h_exists_sl' p) (h_exists_sl' q)
let exists_cong p q =
rewrite_slprop (h_exists p) (h_exists q)
(fun m ->
reveal_equiv (h_exists p) (h_exists q);
exists_equiv p q)
let fresh_invariant #uses p ctxt =
rewrite_slprop p (to_vprop (hp_of p)) (fun _ -> ());
let i = as_atomic_unobservable_action (fresh_invariant uses (hp_of p) ctxt) in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ());
return i
let new_invariant #uses p = let i = fresh_invariant #uses p [] in return i
(*
* AR: SteelAtomic and SteelGhost are not marked reifiable since we intend to run Steel programs natively
* However to implement the with_inv combinators we need to reify their thunks to reprs
* We could implement it better by having support for reification only in the .fst file
* But for now assuming a function
*)
assume val reify_steel_atomic_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames) (#g:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelAtomicBase a framed opened_invariants g pre post req ens)
: repr a framed opened_invariants g pre post req ens
[@@warn_on_use "as_unobservable_atomic_action is a trusted primitive"]
let as_atomic_o_action
(#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(o:observability)
(f:action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x))
= SteelAtomicBaseT?.reflect f
let with_invariant #a #fp #fp' #obs #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x = as_atomic_o_action obs
(Steel.Memory.with_invariant
#a
#(hp_of fp)
#(fun x -> hp_of (fp' x))
#opened
#(hp_of p)
i
(reify_steel_atomic_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return x
assume val reify_steel_ghost_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelGhostBase a framed opened_invariants Unobservable pre post req ens)
: repr a framed opened_invariants Unobservable pre post req ens
let with_invariant_g #a #fp #fp' #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x =
as_atomic_unobservable_action
(Steel.Memory.with_invariant #a #(hp_of fp) #(fun x -> hp_of (fp' x)) #opened #(hp_of p) i (reify_steel_ghost_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return (hide x)
let intro_vrefine v p =
let m = get () in
let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased (vrefine_t v p) = Ghost.hide (Ghost.reveal x) in
change_slprop
v
(vrefine v p)
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let elim_vrefine v p =
let h = get() in
let x : Ghost.erased (vrefine_t v p) = gget (vrefine v p) in
let x' : Ghost.erased (t_of v) = Ghost.hide (Ghost.reveal x) in
change_slprop
(vrefine v p)
v
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let vdep_cond
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q)) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val vdep_cond (v q: vprop) (p: (t_of v -> Tot vprop)) (x1: t_of (v `star` q)) : Tot prop | [] | Steel.Effect.Atomic.vdep_cond | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
v: Steel.Effect.Common.vprop ->
q: Steel.Effect.Common.vprop ->
p: (_: Steel.Effect.Common.t_of v -> Steel.Effect.Common.vprop) ->
x1: Steel.Effect.Common.t_of (Steel.Effect.Common.star v q)
-> Prims.prop | {
"end_col": 17,
"end_line": 727,
"start_col": 2,
"start_line": 727
} |
Prims.Tot | val vdep_cond_recip (v: vprop) (p: (t_of v -> Tot vprop)) (q: vprop) (x2: t_of (vdep v p))
: Tot prop | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let vdep_cond_recip
(v: vprop)
(p: (t_of v -> Tot vprop))
(q: vprop)
(x2: t_of (vdep v p))
: Tot prop
= q == p (dfst (x2 <: dtuple2 (t_of v) (vdep_payload v p))) | val vdep_cond_recip (v: vprop) (p: (t_of v -> Tot vprop)) (q: vprop) (x2: t_of (vdep v p))
: Tot prop
let vdep_cond_recip (v: vprop) (p: (t_of v -> Tot vprop)) (q: vprop) (x2: t_of (vdep v p))
: Tot prop = | false | null | false | q == p (dfst (x2 <: dtuple2 (t_of v) (vdep_payload v p))) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.t_of",
"Steel.Effect.Common.vdep",
"Prims.eq2",
"FStar.Pervasives.dfst",
"Steel.Effect.Common.vdep_payload",
"Prims.dtuple2",
"Prims.prop"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p)
let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m)
let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m)
let witness_exists #a #u #p _ =
SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x)))
let lift_exists #a #u p =
as_atomic_action_ghost (Steel.Memory.lift_h_exists #u (fun x -> hp_of (p x)))
let exists_equiv p q =
Classical.forall_intro_2 reveal_equiv;
h_exists_cong (h_exists_sl' p) (h_exists_sl' q)
let exists_cong p q =
rewrite_slprop (h_exists p) (h_exists q)
(fun m ->
reveal_equiv (h_exists p) (h_exists q);
exists_equiv p q)
let fresh_invariant #uses p ctxt =
rewrite_slprop p (to_vprop (hp_of p)) (fun _ -> ());
let i = as_atomic_unobservable_action (fresh_invariant uses (hp_of p) ctxt) in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ());
return i
let new_invariant #uses p = let i = fresh_invariant #uses p [] in return i
(*
* AR: SteelAtomic and SteelGhost are not marked reifiable since we intend to run Steel programs natively
* However to implement the with_inv combinators we need to reify their thunks to reprs
* We could implement it better by having support for reification only in the .fst file
* But for now assuming a function
*)
assume val reify_steel_atomic_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames) (#g:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelAtomicBase a framed opened_invariants g pre post req ens)
: repr a framed opened_invariants g pre post req ens
[@@warn_on_use "as_unobservable_atomic_action is a trusted primitive"]
let as_atomic_o_action
(#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(o:observability)
(f:action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x))
= SteelAtomicBaseT?.reflect f
let with_invariant #a #fp #fp' #obs #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x = as_atomic_o_action obs
(Steel.Memory.with_invariant
#a
#(hp_of fp)
#(fun x -> hp_of (fp' x))
#opened
#(hp_of p)
i
(reify_steel_atomic_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return x
assume val reify_steel_ghost_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelGhostBase a framed opened_invariants Unobservable pre post req ens)
: repr a framed opened_invariants Unobservable pre post req ens
let with_invariant_g #a #fp #fp' #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x =
as_atomic_unobservable_action
(Steel.Memory.with_invariant #a #(hp_of fp) #(fun x -> hp_of (fp' x)) #opened #(hp_of p) i (reify_steel_ghost_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return (hide x)
let intro_vrefine v p =
let m = get () in
let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased (vrefine_t v p) = Ghost.hide (Ghost.reveal x) in
change_slprop
v
(vrefine v p)
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let elim_vrefine v p =
let h = get() in
let x : Ghost.erased (vrefine_t v p) = gget (vrefine v p) in
let x' : Ghost.erased (t_of v) = Ghost.hide (Ghost.reveal x) in
change_slprop
(vrefine v p)
v
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let vdep_cond
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
: Tot prop
= q == p (fst x1)
let vdep_rel
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
(x2: (t_of (vdep v p)))
: Tot prop
=
q == p (fst x1) /\
dfst (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == fst x1 /\
dsnd (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == snd x1
let intro_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (v `star` q)) m /\
q == p (fst (sel_of (v `star` q) m))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
))
=
Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m
let intro_vdep
v q p
=
reveal_star v q;
change_slprop_rel_with_cond
(v `star` q)
(vdep v p)
(vdep_cond v q p)
(vdep_rel v q p)
(fun m -> intro_vdep_lemma v q p m)
let vdep_cond_recip
(v: vprop)
(p: (t_of v -> Tot vprop))
(q: vprop)
(x2: t_of (vdep v p)) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val vdep_cond_recip (v: vprop) (p: (t_of v -> Tot vprop)) (q: vprop) (x2: t_of (vdep v p))
: Tot prop | [] | Steel.Effect.Atomic.vdep_cond_recip | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
v: Steel.Effect.Common.vprop ->
p: (_: Steel.Effect.Common.t_of v -> Steel.Effect.Common.vprop) ->
q: Steel.Effect.Common.vprop ->
x2: Steel.Effect.Common.t_of (Steel.Effect.Common.vdep v p)
-> Prims.prop | {
"end_col": 59,
"end_line": 778,
"start_col": 2,
"start_line": 778
} |
Prims.Tot | val vdep_rel_recip
(v q: vprop)
(p: (t_of v -> Tot vprop))
(x2: (t_of (vdep v p)))
(x1: t_of (v `star` q))
: Tot prop | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let vdep_rel_recip
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x2: (t_of (vdep v p)))
(x1: t_of (v `star` q))
: Tot prop
=
vdep_rel v q p x1 x2 | val vdep_rel_recip
(v q: vprop)
(p: (t_of v -> Tot vprop))
(x2: (t_of (vdep v p)))
(x1: t_of (v `star` q))
: Tot prop
let vdep_rel_recip
(v q: vprop)
(p: (t_of v -> Tot vprop))
(x2: (t_of (vdep v p)))
(x1: t_of (v `star` q))
: Tot prop = | false | null | false | vdep_rel v q p x1 x2 | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.t_of",
"Steel.Effect.Common.vdep",
"Steel.Effect.Common.star",
"Steel.Effect.Atomic.vdep_rel",
"Prims.prop"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p)
let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m)
let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m)
let witness_exists #a #u #p _ =
SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x)))
let lift_exists #a #u p =
as_atomic_action_ghost (Steel.Memory.lift_h_exists #u (fun x -> hp_of (p x)))
let exists_equiv p q =
Classical.forall_intro_2 reveal_equiv;
h_exists_cong (h_exists_sl' p) (h_exists_sl' q)
let exists_cong p q =
rewrite_slprop (h_exists p) (h_exists q)
(fun m ->
reveal_equiv (h_exists p) (h_exists q);
exists_equiv p q)
let fresh_invariant #uses p ctxt =
rewrite_slprop p (to_vprop (hp_of p)) (fun _ -> ());
let i = as_atomic_unobservable_action (fresh_invariant uses (hp_of p) ctxt) in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ());
return i
let new_invariant #uses p = let i = fresh_invariant #uses p [] in return i
(*
* AR: SteelAtomic and SteelGhost are not marked reifiable since we intend to run Steel programs natively
* However to implement the with_inv combinators we need to reify their thunks to reprs
* We could implement it better by having support for reification only in the .fst file
* But for now assuming a function
*)
assume val reify_steel_atomic_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames) (#g:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelAtomicBase a framed opened_invariants g pre post req ens)
: repr a framed opened_invariants g pre post req ens
[@@warn_on_use "as_unobservable_atomic_action is a trusted primitive"]
let as_atomic_o_action
(#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(o:observability)
(f:action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x))
= SteelAtomicBaseT?.reflect f
let with_invariant #a #fp #fp' #obs #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x = as_atomic_o_action obs
(Steel.Memory.with_invariant
#a
#(hp_of fp)
#(fun x -> hp_of (fp' x))
#opened
#(hp_of p)
i
(reify_steel_atomic_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return x
assume val reify_steel_ghost_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelGhostBase a framed opened_invariants Unobservable pre post req ens)
: repr a framed opened_invariants Unobservable pre post req ens
let with_invariant_g #a #fp #fp' #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x =
as_atomic_unobservable_action
(Steel.Memory.with_invariant #a #(hp_of fp) #(fun x -> hp_of (fp' x)) #opened #(hp_of p) i (reify_steel_ghost_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return (hide x)
let intro_vrefine v p =
let m = get () in
let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased (vrefine_t v p) = Ghost.hide (Ghost.reveal x) in
change_slprop
v
(vrefine v p)
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let elim_vrefine v p =
let h = get() in
let x : Ghost.erased (vrefine_t v p) = gget (vrefine v p) in
let x' : Ghost.erased (t_of v) = Ghost.hide (Ghost.reveal x) in
change_slprop
(vrefine v p)
v
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let vdep_cond
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
: Tot prop
= q == p (fst x1)
let vdep_rel
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
(x2: (t_of (vdep v p)))
: Tot prop
=
q == p (fst x1) /\
dfst (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == fst x1 /\
dsnd (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == snd x1
let intro_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (v `star` q)) m /\
q == p (fst (sel_of (v `star` q) m))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
))
=
Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m
let intro_vdep
v q p
=
reveal_star v q;
change_slprop_rel_with_cond
(v `star` q)
(vdep v p)
(vdep_cond v q p)
(vdep_rel v q p)
(fun m -> intro_vdep_lemma v q p m)
let vdep_cond_recip
(v: vprop)
(p: (t_of v -> Tot vprop))
(q: vprop)
(x2: t_of (vdep v p))
: Tot prop
= q == p (dfst (x2 <: dtuple2 (t_of v) (vdep_payload v p)))
let vdep_rel_recip
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x2: (t_of (vdep v p)))
(x1: t_of (v `star` q))
: Tot prop | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val vdep_rel_recip
(v q: vprop)
(p: (t_of v -> Tot vprop))
(x2: (t_of (vdep v p)))
(x1: t_of (v `star` q))
: Tot prop | [] | Steel.Effect.Atomic.vdep_rel_recip | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
v: Steel.Effect.Common.vprop ->
q: Steel.Effect.Common.vprop ->
p: (_: Steel.Effect.Common.t_of v -> Steel.Effect.Common.vprop) ->
x2: Steel.Effect.Common.t_of (Steel.Effect.Common.vdep v p) ->
x1: Steel.Effect.Common.t_of (Steel.Effect.Common.star v q)
-> Prims.prop | {
"end_col": 22,
"end_line": 788,
"start_col": 2,
"start_line": 788
} |
Steel.Effect.Atomic.SteelGhostF | val sladmit (#a:Type)
(#opened:inames)
(#p:pre_t)
(#q:post_t a)
(_:unit)
: SteelGhostF a opened p q (requires fun _ -> True) (ensures fun _ _ _ -> False) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ()) | val sladmit (#a:Type)
(#opened:inames)
(#p:pre_t)
(#q:post_t a)
(_:unit)
: SteelGhostF a opened p q (requires fun _ -> True) (ensures fun _ _ _ -> False)
let sladmit _ = | true | null | false | SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ()) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.pre_t",
"Steel.Effect.Common.post_t",
"Prims.unit",
"Steel.Memory.slprop",
"FStar.NMSTTotal.nmst_tot_admit",
"Steel.Memory.full_mem",
"Steel.Memory.mem_evolves",
"Steel.Effect.Common.rmem",
"Prims.l_True",
"Prims.l_False"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ()) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val sladmit (#a:Type)
(#opened:inames)
(#p:pre_t)
(#q:post_t a)
(_:unit)
: SteelGhostF a opened p q (requires fun _ -> True) (ensures fun _ _ _ -> False) | [] | Steel.Effect.Atomic.sladmit | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | _: Prims.unit -> Steel.Effect.Atomic.SteelGhostF a | {
"end_col": 75,
"end_line": 546,
"start_col": 16,
"start_line": 546
} |
Steel.Effect.Atomic.SteelGhost | val extract_info_raw (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : SteelGhost unit opened p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l) | val extract_info_raw (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : SteelGhost unit opened p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
let extract_info_raw p fact l = | true | null | false | SteelGhost?.reflect (extract_info_raw0 p fact l) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Prims.prop",
"Steel.Memory.mem",
"Prims.unit",
"Steel.Memory.interp",
"Steel.Effect.Common.hp_of",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Steel.Effect.Atomic.extract_info_raw0",
"Steel.Effect.Common.rmem",
"Prims.l_True",
"Prims.l_and",
"Steel.Effect.Common.frame_equalities"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val extract_info_raw (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : SteelGhost unit opened p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact) | [] | Steel.Effect.Atomic.extract_info_raw | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
p: Steel.Effect.Common.vprop ->
fact: Prims.prop ->
l:
(m: Steel.Memory.mem
-> FStar.Pervasives.Lemma (requires Steel.Memory.interp (Steel.Effect.Common.hp_of p) m)
(ensures fact))
-> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 80,
"end_line": 542,
"start_col": 32,
"start_line": 542
} |
Steel.Effect.Atomic.SteelGhostF | val get (#p:vprop) (#opened:inames) (_:unit) : SteelGhostF (erased (rmem p))
opened
p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let get () = SteelGhost?.reflect (get0 ()) | val get (#p:vprop) (#opened:inames) (_:unit) : SteelGhostF (erased (rmem p))
opened
p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
let get () = | true | null | false | SteelGhost?.reflect (get0 ()) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Effect.Common.vprop",
"Steel.Memory.inames",
"Prims.unit",
"Steel.Effect.Atomic.get0",
"FStar.Ghost.erased",
"Steel.Effect.Common.rmem",
"Prims.l_True",
"Prims.l_and",
"Steel.Effect.Common.frame_equalities",
"FStar.Ghost.reveal"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0 | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val get (#p:vprop) (#opened:inames) (_:unit) : SteelGhostF (erased (rmem p))
opened
p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1) | [] | Steel.Effect.Atomic.get | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | _: Prims.unit -> Steel.Effect.Atomic.SteelGhostF (FStar.Ghost.erased (Steel.Effect.Common.rmem p)) | {
"end_col": 42,
"end_line": 371,
"start_col": 13,
"start_line": 371
} |
Steel.Effect.Atomic.SteelAtomicBase | val return (#a:Type u#a)
(#opened_invariants:inames)
(#p:a -> vprop)
(x:a)
: SteelAtomicBase a true opened_invariants Unobservable
(return_pre (p x)) p
(return_req (p x)) (return_ens a x p) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p) | val return (#a:Type u#a)
(#opened_invariants:inames)
(#p:a -> vprop)
(x:a)
: SteelAtomicBase a true opened_invariants Unobservable
(return_pre (p x)) p
(return_req (p x)) (return_ens a x p)
let return #a #opened #p x = | true | null | false | SteelAtomicBase?.reflect (return_ a x opened #p) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.return_",
"Steel.Effect.Common.Unobservable",
"Steel.Effect.Common.return_pre",
"Steel.Effect.Atomic.return_req",
"Steel.Effect.Atomic.return_ens"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ()) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val return (#a:Type u#a)
(#opened_invariants:inames)
(#p:a -> vprop)
(x:a)
: SteelAtomicBase a true opened_invariants Unobservable
(return_pre (p x)) p
(return_req (p x)) (return_ens a x p) | [] | Steel.Effect.Atomic.return | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | x: a -> Steel.Effect.Atomic.SteelAtomicBase a | {
"end_col": 77,
"end_line": 608,
"start_col": 29,
"start_line": 608
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x)) | let to_post (#a: Type) (post: post_t a) = | false | null | false | fun x -> (hp_of (post x)) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Effect.Common.post_t",
"Steel.Effect.Common.hp_of",
"Steel.Memory.slprop"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val to_post : post: Steel.Effect.Common.post_t a -> x: a -> Steel.Memory.slprop | [] | Steel.Effect.Atomic.to_post | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | post: Steel.Effect.Common.post_t a -> x: a -> Steel.Memory.slprop | {
"end_col": 65,
"end_line": 33,
"start_col": 40,
"start_line": 33
} |
|
Prims.Tot | val return_ (a:Type u#a)
(x:a)
(opened_invariants:inames)
(#[@@@ framing_implicit] p:a -> vprop)
: repr a true opened_invariants Unobservable
(return_pre (p x)) p
(return_req (p x)) (return_ens a x p) | [
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x | val return_ (a:Type u#a)
(x:a)
(opened_invariants:inames)
(#[@@@ framing_implicit] p:a -> vprop)
: repr a true opened_invariants Unobservable
(return_pre (p x)) p
(return_req (p x)) (return_ens a x p)
let return_ a x opened #p = | false | null | false | fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Memory.slprop",
"Prims.unit",
"Steel.Effect.lemma_frame_equalities_refl",
"Steel.Effect.Common.rmem'",
"Steel.Effect.Common.valid_rmem",
"Steel.Effect.Common.mk_rmem",
"Steel.Memory.core_mem",
"Steel.Memory.full_mem",
"FStar.NMSTTotal.get",
"Steel.Memory.mem_evolves"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val return_ (a:Type u#a)
(x:a)
(opened_invariants:inames)
(#[@@@ framing_implicit] p:a -> vprop)
: repr a true opened_invariants Unobservable
(return_pre (p x)) p
(return_req (p x)) (return_ens a x p) | [] | Steel.Effect.Atomic.return_ | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | a: Type -> x: a -> opened_invariants: Steel.Memory.inames
-> Steel.Effect.Atomic.repr a
true
opened_invariants
Steel.Effect.Common.Unobservable
(Steel.Effect.Common.return_pre (p x))
p
(Steel.Effect.Atomic.return_req (p x))
(Steel.Effect.Atomic.return_ens a x p) | {
"end_col": 3,
"end_line": 48,
"start_col": 28,
"start_line": 44
} |
Prims.Tot | val bind_req_opaque:
#a: Type ->
#pre_f: pre_t ->
#post_f: post_t a ->
req_f: req_t pre_f ->
ens_f: ens_t pre_f a post_f ->
#pre_g: (a -> pre_t) ->
#pr: (a -> prop) ->
req_g: (x: a -> req_t (pre_g x)) ->
frame_f: vprop ->
frame_g: (a -> vprop) ->
squash (can_be_split_forall_dep pr
(fun x -> (post_f x) `star` frame_f)
(fun x -> (pre_g x) `star` (frame_g x)))
-> req_t (pre_f `star` frame_f) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)))) | val bind_req_opaque:
#a: Type ->
#pre_f: pre_t ->
#post_f: post_t a ->
req_f: req_t pre_f ->
ens_f: ens_t pre_f a post_f ->
#pre_g: (a -> pre_t) ->
#pr: (a -> prop) ->
req_g: (x: a -> req_t (pre_g x)) ->
frame_f: vprop ->
frame_g: (a -> vprop) ->
squash (can_be_split_forall_dep pr
(fun x -> (post_f x) `star` frame_f)
(fun x -> (pre_g x) `star` (frame_g x)))
-> req_t (pre_f `star` frame_f)
let bind_req_opaque
(#a: Type)
(#pre_f: pre_t)
(#post_f: post_t a)
(req_f: req_t pre_f)
(ens_f: ens_t pre_f a post_f)
(#pre_g: (a -> pre_t))
(#pr: (a -> prop))
(req_g: (x: a -> req_t (pre_g x)))
(frame_f: vprop)
(frame_g: (a -> vprop))
(_:
squash (can_be_split_forall_dep pr
(fun x -> (post_f x) `star` frame_f)
(fun x -> (pre_g x) `star` (frame_g x))))
: req_t (pre_f `star` frame_f) = | false | null | false | fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x: a) (h1: hmem ((post_f x) `star` frame_f)).
(ens_f (focus_rmem m0 pre_f)
x
(focus_rmem (mk_rmem ((post_f x) `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f
(focus_rmem m0 frame_f)
(focus_rmem (mk_rmem ((post_f x) `star` frame_f) h1) frame_f)) ==>
pr x /\
(can_be_split_trans ((post_f x) `star` frame_f) ((pre_g x) `star` (frame_g x)) (pre_g x);
(req_g x) (focus_rmem (mk_rmem ((post_f x) `star` frame_f) h1) (pre_g x)))) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Effect.Common.pre_t",
"Steel.Effect.Common.post_t",
"Steel.Effect.Common.req_t",
"Steel.Effect.Common.ens_t",
"Prims.prop",
"Steel.Effect.Common.vprop",
"Prims.squash",
"Steel.Effect.Common.can_be_split_forall_dep",
"Steel.Effect.Common.star",
"Steel.Effect.Common.rmem",
"Prims.l_and",
"Steel.Effect.Common.focus_rmem",
"Prims.l_Forall",
"Steel.Effect.Common.hmem",
"Prims.l_imp",
"Steel.Effect.Common.mk_rmem",
"Steel.Effect.frame_opaque",
"Prims.unit",
"Steel.Effect.Common.can_be_split_trans"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x))) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bind_req_opaque:
#a: Type ->
#pre_f: pre_t ->
#post_f: post_t a ->
req_f: req_t pre_f ->
ens_f: ens_t pre_f a post_f ->
#pre_g: (a -> pre_t) ->
#pr: (a -> prop) ->
req_g: (x: a -> req_t (pre_g x)) ->
frame_f: vprop ->
frame_g: (a -> vprop) ->
squash (can_be_split_forall_dep pr
(fun x -> (post_f x) `star` frame_f)
(fun x -> (pre_g x) `star` (frame_g x)))
-> req_t (pre_f `star` frame_f) | [] | Steel.Effect.Atomic.bind_req_opaque | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
req_f: Steel.Effect.Common.req_t pre_f ->
ens_f: Steel.Effect.Common.ens_t pre_f a post_f ->
req_g: (x: a -> Steel.Effect.Common.req_t (pre_g x)) ->
frame_f: Steel.Effect.Common.vprop ->
frame_g: (_: a -> Steel.Effect.Common.vprop) ->
_:
Prims.squash (Steel.Effect.Common.can_be_split_forall_dep pr
(fun x -> Steel.Effect.Common.star (post_f x) frame_f)
(fun x -> Steel.Effect.Common.star (pre_g x) (frame_g x)))
-> Steel.Effect.Common.req_t (Steel.Effect.Common.star pre_f frame_f) | {
"end_col": 79,
"end_line": 138,
"start_col": 2,
"start_line": 131
} |
Prims.Tot | val ens_to_act_ens (#pre: pre_t) (#a: Type) (#post: post_t a) (ens: ens_t pre a post)
: mprop2 (hp_of pre) (to_post post) | [
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1) | val ens_to_act_ens (#pre: pre_t) (#a: Type) (#post: post_t a) (ens: ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
let ens_to_act_ens (#pre: pre_t) (#a: Type) (#post: post_t a) (ens: ens_t pre a post)
: mprop2 (hp_of pre) (to_post post) = | false | null | false | fun m0 x m1 ->
interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Effect.Common.pre_t",
"Steel.Effect.Common.post_t",
"Steel.Effect.Common.ens_t",
"Steel.Memory.mem",
"Prims.l_and",
"Steel.Memory.interp",
"Steel.Effect.Common.hp_of",
"Steel.Effect.Common.mk_rmem",
"Prims.prop",
"Steel.Memory.mprop2",
"Steel.Effect.Atomic.to_post"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ens_to_act_ens (#pre: pre_t) (#a: Type) (#post: post_t a) (ens: ens_t pre a post)
: mprop2 (hp_of pre) (to_post post) | [] | Steel.Effect.Atomic.ens_to_act_ens | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | ens: Steel.Effect.Common.ens_t pre a post
-> Steel.Memory.mprop2 (Steel.Effect.Common.hp_of pre) (Steel.Effect.Atomic.to_post post) | {
"end_col": 48,
"end_line": 38,
"start_col": 2,
"start_line": 37
} |
Prims.Tot | val bind_ens_opaque:
#a: Type ->
#b: Type ->
#pre_f: pre_t ->
#post_f: post_t a ->
req_f: req_t pre_f ->
ens_f: ens_t pre_f a post_f ->
#pre_g: (a -> pre_t) ->
#post_g: (a -> post_t b) ->
#pr: (a -> prop) ->
ens_g: (x: a -> ens_t (pre_g x) b (post_g x)) ->
frame_f: vprop ->
frame_g: (a -> vprop) ->
post: post_t b ->
squash (can_be_split_forall_dep pr
(fun x -> (post_f x) `star` frame_f)
(fun x -> (pre_g x) `star` (frame_g x))) ->
squash (can_be_split_post (fun x y -> (post_g x y) `star` (frame_g x)) post)
-> ens_t (pre_f `star` frame_f) b post | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y)))) | val bind_ens_opaque:
#a: Type ->
#b: Type ->
#pre_f: pre_t ->
#post_f: post_t a ->
req_f: req_t pre_f ->
ens_f: ens_t pre_f a post_f ->
#pre_g: (a -> pre_t) ->
#post_g: (a -> post_t b) ->
#pr: (a -> prop) ->
ens_g: (x: a -> ens_t (pre_g x) b (post_g x)) ->
frame_f: vprop ->
frame_g: (a -> vprop) ->
post: post_t b ->
squash (can_be_split_forall_dep pr
(fun x -> (post_f x) `star` frame_f)
(fun x -> (pre_g x) `star` (frame_g x))) ->
squash (can_be_split_post (fun x y -> (post_g x y) `star` (frame_g x)) post)
-> ens_t (pre_f `star` frame_f) b post
let bind_ens_opaque
(#a: Type)
(#b: Type)
(#pre_f: pre_t)
(#post_f: post_t a)
(req_f: req_t pre_f)
(ens_f: ens_t pre_f a post_f)
(#pre_g: (a -> pre_t))
(#post_g: (a -> post_t b))
(#pr: (a -> prop))
(ens_g: (x: a -> ens_t (pre_g x) b (post_g x)))
(frame_f: vprop)
(frame_g: (a -> vprop))
(post: post_t b)
(_:
squash (can_be_split_forall_dep pr
(fun x -> (post_f x) `star` frame_f)
(fun x -> (pre_g x) `star` (frame_g x))))
(_: squash (can_be_split_post (fun x y -> (post_g x y) `star` (frame_g x)) post))
: ens_t (pre_f `star` frame_f) b post = | false | null | false | fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x: a) (h1: hmem ((post_f x) `star` frame_f)).
pr x /\
(can_be_split_trans ((post_f x) `star` frame_f) ((pre_g x) `star` (frame_g x)) (pre_g x);
can_be_split_trans ((post_f x) `star` frame_f) ((pre_g x) `star` (frame_g x)) (frame_g x);
can_be_split_trans (post y) ((post_g x y) `star` (frame_g x)) (post_g x y);
can_be_split_trans (post y) ((post_g x y) `star` (frame_g x)) (frame_g x);
frame_opaque frame_f
(focus_rmem m0 frame_f)
(focus_rmem (mk_rmem ((post_f x) `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x)
(focus_rmem (mk_rmem ((post_f x) `star` frame_f) h1) (frame_g x))
(focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f)
x
(focus_rmem (mk_rmem ((post_f x) `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem ((post_f x) `star` frame_f) h1) (pre_g x))
y
(focus_rmem m2 (post_g x y)))) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Effect.Common.pre_t",
"Steel.Effect.Common.post_t",
"Steel.Effect.Common.req_t",
"Steel.Effect.Common.ens_t",
"Prims.prop",
"Steel.Effect.Common.vprop",
"Prims.squash",
"Steel.Effect.Common.can_be_split_forall_dep",
"Steel.Effect.Common.star",
"Steel.Effect.Common.can_be_split_post",
"Steel.Effect.Common.rmem",
"Prims.l_and",
"Steel.Effect.Common.focus_rmem",
"Prims.l_Exists",
"Steel.Effect.Common.hmem",
"Steel.Effect.frame_opaque",
"Steel.Effect.Common.mk_rmem",
"Prims.unit",
"Steel.Effect.Common.can_be_split_trans"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post)) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bind_ens_opaque:
#a: Type ->
#b: Type ->
#pre_f: pre_t ->
#post_f: post_t a ->
req_f: req_t pre_f ->
ens_f: ens_t pre_f a post_f ->
#pre_g: (a -> pre_t) ->
#post_g: (a -> post_t b) ->
#pr: (a -> prop) ->
ens_g: (x: a -> ens_t (pre_g x) b (post_g x)) ->
frame_f: vprop ->
frame_g: (a -> vprop) ->
post: post_t b ->
squash (can_be_split_forall_dep pr
(fun x -> (post_f x) `star` frame_f)
(fun x -> (pre_g x) `star` (frame_g x))) ->
squash (can_be_split_post (fun x y -> (post_g x y) `star` (frame_g x)) post)
-> ens_t (pre_f `star` frame_f) b post | [] | Steel.Effect.Atomic.bind_ens_opaque | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
req_f: Steel.Effect.Common.req_t pre_f ->
ens_f: Steel.Effect.Common.ens_t pre_f a post_f ->
ens_g: (x: a -> Steel.Effect.Common.ens_t (pre_g x) b (post_g x)) ->
frame_f: Steel.Effect.Common.vprop ->
frame_g: (_: a -> Steel.Effect.Common.vprop) ->
post: Steel.Effect.Common.post_t b ->
_:
Prims.squash (Steel.Effect.Common.can_be_split_forall_dep pr
(fun x -> Steel.Effect.Common.star (post_f x) frame_f)
(fun x -> Steel.Effect.Common.star (pre_g x) (frame_g x))) ->
_:
Prims.squash (Steel.Effect.Common.can_be_split_post (fun x y ->
Steel.Effect.Common.star (post_g x y) (frame_g x))
post)
-> Steel.Effect.Common.ens_t (Steel.Effect.Common.star pre_f frame_f) b post | {
"end_col": 108,
"end_line": 164,
"start_col": 2,
"start_line": 152
} |
Prims.Tot | val norm_repr
(#a: Type)
(#framed: bool)
(#opened: inames)
(#obs: observability)
(#pre: pre_t)
(#post: post_t a)
(#req: req_t pre)
(#ens: ens_t pre a post)
(f: repr a framed opened obs pre post req ens)
: repr a
framed
opened
obs
pre
post
(fun h -> norm_opaque (req h))
(fun h0 x h1 -> norm_opaque (ens h0 x h1)) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f | val norm_repr
(#a: Type)
(#framed: bool)
(#opened: inames)
(#obs: observability)
(#pre: pre_t)
(#post: post_t a)
(#req: req_t pre)
(#ens: ens_t pre a post)
(f: repr a framed opened obs pre post req ens)
: repr a
framed
opened
obs
pre
post
(fun h -> norm_opaque (req h))
(fun h0 x h1 -> norm_opaque (ens h0 x h1))
let norm_repr
(#a: Type)
(#framed: bool)
(#opened: inames)
(#obs: observability)
(#pre: pre_t)
(#post: post_t a)
(#req: req_t pre)
(#ens: ens_t pre a post)
(f: repr a framed opened obs pre post req ens)
: repr a
framed
opened
obs
pre
post
(fun h -> norm_opaque (req h))
(fun h0 x h1 -> norm_opaque (ens h0 x h1)) = | false | null | false | f | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Prims.bool",
"Steel.Memory.inames",
"Steel.Effect.Common.observability",
"Steel.Effect.Common.pre_t",
"Steel.Effect.Common.post_t",
"Steel.Effect.Common.req_t",
"Steel.Effect.Common.ens_t",
"Steel.Effect.Atomic.repr",
"Steel.Effect.Common.rmem",
"Steel.Effect.norm_opaque"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val norm_repr
(#a: Type)
(#framed: bool)
(#opened: inames)
(#obs: observability)
(#pre: pre_t)
(#post: post_t a)
(#req: req_t pre)
(#ens: ens_t pre a post)
(f: repr a framed opened obs pre post req ens)
: repr a
framed
opened
obs
pre
post
(fun h -> norm_opaque (req h))
(fun h0 x h1 -> norm_opaque (ens h0 x h1)) | [] | Steel.Effect.Atomic.norm_repr | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | f: Steel.Effect.Atomic.repr a framed opened obs pre post req ens
-> Steel.Effect.Atomic.repr a
framed
opened
obs
pre
post
(fun h -> Steel.Effect.norm_opaque (req h))
(fun h0 x h1 -> Steel.Effect.norm_opaque (ens h0 x h1)) | {
"end_col": 4,
"end_line": 277,
"start_col": 3,
"start_line": 277
} |
Prims.Pure | val subcomp (a:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f: eqtype_as_type bool)
(#framed_g: eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p: prop)
(#[@@@ framing_implicit] p1:squash (can_be_split_dep p pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened_invariants o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f | val subcomp (a:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f: eqtype_as_type bool)
(#framed_g: eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p: prop)
(#[@@@ framing_implicit] p1:squash (can_be_split_dep p pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened_invariants o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp
a
opened
o1
o2
#framed_f
#framed_g
#pre_f
#post_f
#req_f
#ens_f
#pre_g
#post_g
#req_g
#ens_g
#fr
#_
#pr
#p1
#p2
f
= | false | null | false | lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g
#ens_g #fr #pr #_ #p1 #p2 f | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"FStar.Pervasives.eqtype_as_type",
"Steel.Effect.Common.observability",
"Prims.bool",
"Steel.Effect.Common.pre_t",
"Steel.Effect.Common.post_t",
"Steel.Effect.Common.req_t",
"Steel.Effect.Common.ens_t",
"Steel.Effect.Common.vprop",
"Prims.squash",
"Steel.Effect.Common.maybe_emp",
"Prims.prop",
"Steel.Effect.Common.can_be_split_dep",
"Steel.Effect.Common.star",
"Steel.Effect.Common.equiv_forall",
"Steel.Effect.Atomic.repr",
"Steel.Effect.Atomic.subcomp_opaque",
"Prims.unit",
"Steel.Effect.lemma_subcomp_pre_opaque"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val subcomp (a:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f: eqtype_as_type bool)
(#framed_g: eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p: prop)
(#[@@@ framing_implicit] p1:squash (can_be_split_dep p pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened_invariants o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True) | [] | Steel.Effect.Atomic.subcomp | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
a: Type ->
opened_invariants: Steel.Memory.inames ->
o1: FStar.Pervasives.eqtype_as_type Steel.Effect.Common.observability ->
o2: FStar.Pervasives.eqtype_as_type Steel.Effect.Common.observability ->
f: Steel.Effect.Atomic.repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f
-> Prims.Pure (Steel.Effect.Atomic.repr a framed_g opened_invariants o2 pre_g post_g req_g ens_g) | {
"end_col": 130,
"end_line": 341,
"start_col": 2,
"start_line": 340
} |
Prims.Tot | val extract_info_raw0
(#opened: inames)
(p: vprop)
(fact: prop)
(l: (m: mem -> Lemma (requires interp (hp_of p) m) (ensures fact)))
: repr unit
false
opened
Unobservable
p
(fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact) | [
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0) | val extract_info_raw0
(#opened: inames)
(p: vprop)
(fact: prop)
(l: (m: mem -> Lemma (requires interp (hp_of p) m) (ensures fact)))
: repr unit
false
opened
Unobservable
p
(fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
let extract_info_raw0
(#opened: inames)
(p: vprop)
(fact: prop)
(l: (m: mem -> Lemma (requires interp (hp_of p) m) (ensures fact)))
: repr unit
false
opened
Unobservable
p
(fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact) = | false | null | false | fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Prims.prop",
"Steel.Memory.mem",
"Prims.unit",
"Steel.Memory.interp",
"Steel.Effect.Common.hp_of",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Steel.Memory.slprop",
"Steel.Memory.core_mem",
"Steel.Effect.lemma_frame_equalities_refl",
"Steel.Effect.Common.rmem'",
"Steel.Effect.Common.valid_rmem",
"Steel.Effect.Common.mk_rmem",
"Steel.Memory.full_mem",
"FStar.NMSTTotal.get",
"Steel.Memory.mem_evolves",
"Steel.Effect.Atomic.repr",
"Steel.Effect.Common.Unobservable",
"Steel.Effect.Common.rmem",
"Prims.l_True",
"Prims.l_and",
"Steel.Effect.Common.frame_equalities"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val extract_info_raw0
(#opened: inames)
(p: vprop)
(fact: prop)
(l: (m: mem -> Lemma (requires interp (hp_of p) m) (ensures fact)))
: repr unit
false
opened
Unobservable
p
(fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact) | [] | Steel.Effect.Atomic.extract_info_raw0 | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
p: Steel.Effect.Common.vprop ->
fact: Prims.prop ->
l:
(m: Steel.Memory.mem
-> FStar.Pervasives.Lemma (requires Steel.Memory.interp (Steel.Effect.Common.hp_of p) m)
(ensures fact))
-> Steel.Effect.Atomic.repr Prims.unit
false
opened
Steel.Effect.Common.Unobservable
p
(fun _ -> p)
(fun _ -> Prims.l_True)
(fun h0 _ h1 -> Steel.Effect.Common.frame_equalities p h0 h1 /\ fact) | {
"end_col": 21,
"end_line": 540,
"start_col": 4,
"start_line": 536
} |
Prims.Tot | val rewrite_slprop0
(#opened: inames)
(p q: vprop)
(proof: (m: mem -> Lemma (requires interp (hp_of p) m) (ensures interp (hp_of q) m)))
: repr unit false opened Unobservable p (fun _ -> q) (fun _ -> True) (fun _ _ _ -> True) | [
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m) | val rewrite_slprop0
(#opened: inames)
(p q: vprop)
(proof: (m: mem -> Lemma (requires interp (hp_of p) m) (ensures interp (hp_of q) m)))
: repr unit false opened Unobservable p (fun _ -> q) (fun _ -> True) (fun _ _ _ -> True)
let rewrite_slprop0
(#opened: inames)
(p q: vprop)
(proof: (m: mem -> Lemma (requires interp (hp_of p) m) (ensures interp (hp_of q) m)))
: repr unit false opened Unobservable p (fun _ -> q) (fun _ -> True) (fun _ _ _ -> True) = | false | null | false | fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` (locks_invariant opened m)) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Memory.mem",
"Prims.unit",
"Steel.Memory.interp",
"Steel.Effect.Common.hp_of",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Steel.Memory.slprop",
"Steel.Memory.star_associative",
"Steel.Memory.locks_invariant",
"Steel.Effect.Atomic.intro_star",
"Steel.Memory.star",
"FStar.Ghost.hide",
"Steel.Effect.Common.t_of",
"Steel.Effect.Common.sel_of",
"FStar.Classical.forall_intro",
"Prims.l_imp",
"FStar.Classical.move_requires",
"Steel.Memory.core_mem",
"Steel.Memory.full_mem",
"FStar.NMSTTotal.get",
"Steel.Memory.mem_evolves",
"Steel.Effect.Atomic.repr",
"Steel.Effect.Common.Unobservable",
"Steel.Effect.Common.rmem",
"Prims.l_True"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val rewrite_slprop0
(#opened: inames)
(p q: vprop)
(proof: (m: mem -> Lemma (requires interp (hp_of p) m) (ensures interp (hp_of q) m)))
: repr unit false opened Unobservable p (fun _ -> q) (fun _ -> True) (fun _ _ _ -> True) | [] | Steel.Effect.Atomic.rewrite_slprop0 | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
p: Steel.Effect.Common.vprop ->
q: Steel.Effect.Common.vprop ->
proof:
(m: Steel.Memory.mem
-> FStar.Pervasives.Lemma (requires Steel.Memory.interp (Steel.Effect.Common.hp_of p) m)
(ensures Steel.Memory.interp (Steel.Effect.Common.hp_of q) m))
-> Steel.Effect.Atomic.repr Prims.unit
false
opened
Steel.Effect.Common.Unobservable
p
(fun _ -> q)
(fun _ -> Prims.l_True)
(fun _ _ _ -> Prims.l_True) | {
"end_col": 69,
"end_line": 405,
"start_col": 4,
"start_line": 399
} |
Prims.Pure | val bind (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:a -> pre_t) (#[@@@ framing_implicit] post_g:a -> post_t b)
(#[@@@ framing_implicit] req_g:(x:a -> req_t (pre_g x))) (#[@@@ framing_implicit] ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#[@@@ framing_implicit] frame_f:vprop) (#[@@@ framing_implicit] frame_g:a -> vprop)
(#[@@@ framing_implicit] post:post_t b)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame_f))
(#[@@@ framing_implicit] _ : squash (maybe_emp_dep framed_g frame_g))
(#[@@@ framing_implicit] pr:a -> prop)
(#[@@@ framing_implicit] p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#[@@@ framing_implicit] p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req req_f ens_f req_g frame_f frame_g p1)
(bind_ens req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g) | val bind (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:a -> pre_t) (#[@@@ framing_implicit] post_g:a -> post_t b)
(#[@@@ framing_implicit] req_g:(x:a -> req_t (pre_g x))) (#[@@@ framing_implicit] ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#[@@@ framing_implicit] frame_f:vprop) (#[@@@ framing_implicit] frame_g:a -> vprop)
(#[@@@ framing_implicit] post:post_t b)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame_f))
(#[@@@ framing_implicit] _ : squash (maybe_emp_dep framed_g frame_g))
(#[@@@ framing_implicit] pr:a -> prop)
(#[@@@ framing_implicit] p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#[@@@ framing_implicit] p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req req_f ens_f req_g frame_f frame_g p1)
(bind_ens req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
let bind
a
b
opened
o1
o2
#framed_f
#framed_g
#pre_f
#post_f
#req_f
#ens_f
#pre_g
#post_g
#req_g
#ens_g
#frame_f
#frame_g
#post
#_
#_
#p
#p2
f
g
= | false | null | false | norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g
#post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"FStar.Pervasives.eqtype_as_type",
"Steel.Effect.Common.observability",
"Prims.bool",
"Steel.Effect.Common.pre_t",
"Steel.Effect.Common.post_t",
"Steel.Effect.Common.req_t",
"Steel.Effect.Common.ens_t",
"Steel.Effect.Common.vprop",
"Prims.squash",
"Steel.Effect.Common.maybe_emp",
"Steel.Effect.Common.maybe_emp_dep",
"Prims.prop",
"Steel.Effect.Common.can_be_split_forall_dep",
"Steel.Effect.Common.star",
"Steel.Effect.Common.can_be_split_post",
"Steel.Effect.Atomic.repr",
"Steel.Effect.Atomic.norm_repr",
"Steel.Effect.Common.join_obs",
"Steel.Effect.Atomic.bind_req_opaque",
"Steel.Effect.Atomic.bind_ens_opaque",
"Steel.Effect.Atomic.bind_opaque",
"Steel.Effect.Atomic.bind_req",
"Steel.Effect.Atomic.bind_ens"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bind (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:a -> pre_t) (#[@@@ framing_implicit] post_g:a -> post_t b)
(#[@@@ framing_implicit] req_g:(x:a -> req_t (pre_g x))) (#[@@@ framing_implicit] ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#[@@@ framing_implicit] frame_f:vprop) (#[@@@ framing_implicit] frame_g:a -> vprop)
(#[@@@ framing_implicit] post:post_t b)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame_f))
(#[@@@ framing_implicit] _ : squash (maybe_emp_dep framed_g frame_g))
(#[@@@ framing_implicit] pr:a -> prop)
(#[@@@ framing_implicit] p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#[@@@ framing_implicit] p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req req_f ens_f req_g frame_f frame_g p1)
(bind_ens req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True) | [] | Steel.Effect.Atomic.bind | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
a: Type ->
b: Type ->
opened_invariants: Steel.Memory.inames ->
o1: FStar.Pervasives.eqtype_as_type Steel.Effect.Common.observability ->
o2: FStar.Pervasives.eqtype_as_type Steel.Effect.Common.observability ->
f: Steel.Effect.Atomic.repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f ->
g:
(x: a
-> Steel.Effect.Atomic.repr b
framed_g
opened_invariants
o2
(pre_g x)
(post_g x)
(req_g x)
(ens_g x))
-> Prims.Pure
(Steel.Effect.Atomic.repr b
true
opened_invariants
(Steel.Effect.Common.join_obs o1 o2)
(Steel.Effect.Common.star pre_f frame_f)
post
(Steel.Effect.Atomic.bind_req req_f ens_f req_g frame_f frame_g p1)
(Steel.Effect.Atomic.bind_ens req_f ens_f ens_g frame_f frame_g post p1 p2)) | {
"end_col": 163,
"end_line": 280,
"start_col": 4,
"start_line": 280
} |
FStar.Pervasives.Lemma | val intro_vdep_lemma (v q: vprop) (p: (t_of v -> Tot vprop)) (m: mem)
: Lemma (requires (interp (hp_of (v `star` q)) m /\ q == p (fst (sel_of (v `star` q) m))))
(ensures
(interp (hp_of (v `star` q)) m /\ interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m))) | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let intro_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (v `star` q)) m /\
q == p (fst (sel_of (v `star` q) m))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
))
=
Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m | val intro_vdep_lemma (v q: vprop) (p: (t_of v -> Tot vprop)) (m: mem)
: Lemma (requires (interp (hp_of (v `star` q)) m /\ q == p (fst (sel_of (v `star` q) m))))
(ensures
(interp (hp_of (v `star` q)) m /\ interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)))
let intro_vdep_lemma (v q: vprop) (p: (t_of v -> Tot vprop)) (m: mem)
: Lemma (requires (interp (hp_of (v `star` q)) m /\ q == p (fst (sel_of (v `star` q) m))))
(ensures
(interp (hp_of (v `star` q)) m /\ interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m))) = | false | null | true | Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"lemma"
] | [
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.t_of",
"Steel.Memory.mem",
"Steel.Effect.Common.vdep_sel_eq",
"Prims.unit",
"Steel.Effect.Common.interp_vdep_hp",
"Steel.Memory.interp_star",
"Steel.Effect.Common.hp_of",
"Prims.l_and",
"Steel.Memory.interp",
"Steel.Effect.Common.star",
"Prims.eq2",
"FStar.Pervasives.Native.fst",
"Steel.Effect.Common.sel_of",
"Prims.squash",
"Steel.Effect.Common.vdep",
"Steel.Effect.Atomic.vdep_rel",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p)
let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m)
let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m)
let witness_exists #a #u #p _ =
SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x)))
let lift_exists #a #u p =
as_atomic_action_ghost (Steel.Memory.lift_h_exists #u (fun x -> hp_of (p x)))
let exists_equiv p q =
Classical.forall_intro_2 reveal_equiv;
h_exists_cong (h_exists_sl' p) (h_exists_sl' q)
let exists_cong p q =
rewrite_slprop (h_exists p) (h_exists q)
(fun m ->
reveal_equiv (h_exists p) (h_exists q);
exists_equiv p q)
let fresh_invariant #uses p ctxt =
rewrite_slprop p (to_vprop (hp_of p)) (fun _ -> ());
let i = as_atomic_unobservable_action (fresh_invariant uses (hp_of p) ctxt) in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ());
return i
let new_invariant #uses p = let i = fresh_invariant #uses p [] in return i
(*
* AR: SteelAtomic and SteelGhost are not marked reifiable since we intend to run Steel programs natively
* However to implement the with_inv combinators we need to reify their thunks to reprs
* We could implement it better by having support for reification only in the .fst file
* But for now assuming a function
*)
assume val reify_steel_atomic_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames) (#g:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelAtomicBase a framed opened_invariants g pre post req ens)
: repr a framed opened_invariants g pre post req ens
[@@warn_on_use "as_unobservable_atomic_action is a trusted primitive"]
let as_atomic_o_action
(#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(o:observability)
(f:action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x))
= SteelAtomicBaseT?.reflect f
let with_invariant #a #fp #fp' #obs #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x = as_atomic_o_action obs
(Steel.Memory.with_invariant
#a
#(hp_of fp)
#(fun x -> hp_of (fp' x))
#opened
#(hp_of p)
i
(reify_steel_atomic_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return x
assume val reify_steel_ghost_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelGhostBase a framed opened_invariants Unobservable pre post req ens)
: repr a framed opened_invariants Unobservable pre post req ens
let with_invariant_g #a #fp #fp' #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x =
as_atomic_unobservable_action
(Steel.Memory.with_invariant #a #(hp_of fp) #(fun x -> hp_of (fp' x)) #opened #(hp_of p) i (reify_steel_ghost_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return (hide x)
let intro_vrefine v p =
let m = get () in
let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased (vrefine_t v p) = Ghost.hide (Ghost.reveal x) in
change_slprop
v
(vrefine v p)
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let elim_vrefine v p =
let h = get() in
let x : Ghost.erased (vrefine_t v p) = gget (vrefine v p) in
let x' : Ghost.erased (t_of v) = Ghost.hide (Ghost.reveal x) in
change_slprop
(vrefine v p)
v
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let vdep_cond
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
: Tot prop
= q == p (fst x1)
let vdep_rel
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
(x2: (t_of (vdep v p)))
: Tot prop
=
q == p (fst x1) /\
dfst (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == fst x1 /\
dsnd (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == snd x1
let intro_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (v `star` q)) m /\
q == p (fst (sel_of (v `star` q) m))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
)) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val intro_vdep_lemma (v q: vprop) (p: (t_of v -> Tot vprop)) (m: mem)
: Lemma (requires (interp (hp_of (v `star` q)) m /\ q == p (fst (sel_of (v `star` q) m))))
(ensures
(interp (hp_of (v `star` q)) m /\ interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m))) | [] | Steel.Effect.Atomic.intro_vdep_lemma | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
v: Steel.Effect.Common.vprop ->
q: Steel.Effect.Common.vprop ->
p: (_: Steel.Effect.Common.t_of v -> Steel.Effect.Common.vprop) ->
m: Steel.Memory.mem
-> FStar.Pervasives.Lemma
(requires
Steel.Memory.interp (Steel.Effect.Common.hp_of (Steel.Effect.Common.star v q)) m /\
q ==
p (FStar.Pervasives.Native.fst (Steel.Effect.Common.sel_of (Steel.Effect.Common.star v q) m)
))
(ensures
Steel.Memory.interp (Steel.Effect.Common.hp_of (Steel.Effect.Common.star v q)) m /\
Steel.Memory.interp (Steel.Effect.Common.hp_of (Steel.Effect.Common.vdep v p)) m /\
Steel.Effect.Atomic.vdep_rel v
q
p
(Steel.Effect.Common.sel_of (Steel.Effect.Common.star v q) m)
(Steel.Effect.Common.sel_of (Steel.Effect.Common.vdep v p) m)) | {
"end_col": 19,
"end_line": 759,
"start_col": 2,
"start_line": 757
} |
FStar.Pervasives.Lemma | val elim_vdep_lemma (v q: vprop) (p: (t_of v -> Tot vprop)) (m: mem)
: Lemma
(requires
(interp (hp_of (vdep v p)) m /\
q == p (dfst (sel_of (vdep v p) m <: dtuple2 (t_of v) (vdep_payload v p)))))
(ensures
(interp (hp_of (v `star` q)) m /\ interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m))) | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let elim_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (vdep v p)) m /\
q == p (dfst (sel_of (vdep v p) m <: dtuple2 (t_of v) (vdep_payload v p)))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
))
=
Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m | val elim_vdep_lemma (v q: vprop) (p: (t_of v -> Tot vprop)) (m: mem)
: Lemma
(requires
(interp (hp_of (vdep v p)) m /\
q == p (dfst (sel_of (vdep v p) m <: dtuple2 (t_of v) (vdep_payload v p)))))
(ensures
(interp (hp_of (v `star` q)) m /\ interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)))
let elim_vdep_lemma (v q: vprop) (p: (t_of v -> Tot vprop)) (m: mem)
: Lemma
(requires
(interp (hp_of (vdep v p)) m /\
q == p (dfst (sel_of (vdep v p) m <: dtuple2 (t_of v) (vdep_payload v p)))))
(ensures
(interp (hp_of (v `star` q)) m /\ interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m))) = | false | null | true | Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"lemma"
] | [
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.t_of",
"Steel.Memory.mem",
"Steel.Effect.Common.vdep_sel_eq",
"Prims.unit",
"Steel.Effect.Common.interp_vdep_hp",
"Steel.Memory.interp_star",
"Steel.Effect.Common.hp_of",
"Prims.l_and",
"Steel.Memory.interp",
"Steel.Effect.Common.vdep",
"Prims.eq2",
"FStar.Pervasives.dfst",
"Steel.Effect.Common.vdep_payload",
"Steel.Effect.Common.sel_of",
"Prims.dtuple2",
"Prims.squash",
"Steel.Effect.Common.star",
"Steel.Effect.Atomic.vdep_rel",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p)
let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m)
let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m)
let witness_exists #a #u #p _ =
SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x)))
let lift_exists #a #u p =
as_atomic_action_ghost (Steel.Memory.lift_h_exists #u (fun x -> hp_of (p x)))
let exists_equiv p q =
Classical.forall_intro_2 reveal_equiv;
h_exists_cong (h_exists_sl' p) (h_exists_sl' q)
let exists_cong p q =
rewrite_slprop (h_exists p) (h_exists q)
(fun m ->
reveal_equiv (h_exists p) (h_exists q);
exists_equiv p q)
let fresh_invariant #uses p ctxt =
rewrite_slprop p (to_vprop (hp_of p)) (fun _ -> ());
let i = as_atomic_unobservable_action (fresh_invariant uses (hp_of p) ctxt) in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ());
return i
let new_invariant #uses p = let i = fresh_invariant #uses p [] in return i
(*
* AR: SteelAtomic and SteelGhost are not marked reifiable since we intend to run Steel programs natively
* However to implement the with_inv combinators we need to reify their thunks to reprs
* We could implement it better by having support for reification only in the .fst file
* But for now assuming a function
*)
assume val reify_steel_atomic_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames) (#g:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelAtomicBase a framed opened_invariants g pre post req ens)
: repr a framed opened_invariants g pre post req ens
[@@warn_on_use "as_unobservable_atomic_action is a trusted primitive"]
let as_atomic_o_action
(#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(o:observability)
(f:action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x))
= SteelAtomicBaseT?.reflect f
let with_invariant #a #fp #fp' #obs #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x = as_atomic_o_action obs
(Steel.Memory.with_invariant
#a
#(hp_of fp)
#(fun x -> hp_of (fp' x))
#opened
#(hp_of p)
i
(reify_steel_atomic_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return x
assume val reify_steel_ghost_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelGhostBase a framed opened_invariants Unobservable pre post req ens)
: repr a framed opened_invariants Unobservable pre post req ens
let with_invariant_g #a #fp #fp' #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x =
as_atomic_unobservable_action
(Steel.Memory.with_invariant #a #(hp_of fp) #(fun x -> hp_of (fp' x)) #opened #(hp_of p) i (reify_steel_ghost_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return (hide x)
let intro_vrefine v p =
let m = get () in
let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased (vrefine_t v p) = Ghost.hide (Ghost.reveal x) in
change_slprop
v
(vrefine v p)
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let elim_vrefine v p =
let h = get() in
let x : Ghost.erased (vrefine_t v p) = gget (vrefine v p) in
let x' : Ghost.erased (t_of v) = Ghost.hide (Ghost.reveal x) in
change_slprop
(vrefine v p)
v
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let vdep_cond
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
: Tot prop
= q == p (fst x1)
let vdep_rel
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
(x2: (t_of (vdep v p)))
: Tot prop
=
q == p (fst x1) /\
dfst (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == fst x1 /\
dsnd (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == snd x1
let intro_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (v `star` q)) m /\
q == p (fst (sel_of (v `star` q) m))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
))
=
Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m
let intro_vdep
v q p
=
reveal_star v q;
change_slprop_rel_with_cond
(v `star` q)
(vdep v p)
(vdep_cond v q p)
(vdep_rel v q p)
(fun m -> intro_vdep_lemma v q p m)
let vdep_cond_recip
(v: vprop)
(p: (t_of v -> Tot vprop))
(q: vprop)
(x2: t_of (vdep v p))
: Tot prop
= q == p (dfst (x2 <: dtuple2 (t_of v) (vdep_payload v p)))
let vdep_rel_recip
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x2: (t_of (vdep v p)))
(x1: t_of (v `star` q))
: Tot prop
=
vdep_rel v q p x1 x2
let elim_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (vdep v p)) m /\
q == p (dfst (sel_of (vdep v p) m <: dtuple2 (t_of v) (vdep_payload v p)))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
)) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val elim_vdep_lemma (v q: vprop) (p: (t_of v -> Tot vprop)) (m: mem)
: Lemma
(requires
(interp (hp_of (vdep v p)) m /\
q == p (dfst (sel_of (vdep v p) m <: dtuple2 (t_of v) (vdep_payload v p)))))
(ensures
(interp (hp_of (v `star` q)) m /\ interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m))) | [] | Steel.Effect.Atomic.elim_vdep_lemma | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
v: Steel.Effect.Common.vprop ->
q: Steel.Effect.Common.vprop ->
p: (_: Steel.Effect.Common.t_of v -> Steel.Effect.Common.vprop) ->
m: Steel.Memory.mem
-> FStar.Pervasives.Lemma
(requires
Steel.Memory.interp (Steel.Effect.Common.hp_of (Steel.Effect.Common.vdep v p)) m /\
q == p (FStar.Pervasives.dfst (Steel.Effect.Common.sel_of (Steel.Effect.Common.vdep v p) m))
)
(ensures
Steel.Memory.interp (Steel.Effect.Common.hp_of (Steel.Effect.Common.star v q)) m /\
Steel.Memory.interp (Steel.Effect.Common.hp_of (Steel.Effect.Common.vdep v p)) m /\
Steel.Effect.Atomic.vdep_rel v
q
p
(Steel.Effect.Common.sel_of (Steel.Effect.Common.star v q) m)
(Steel.Effect.Common.sel_of (Steel.Effect.Common.vdep v p) m)) | {
"end_col": 19,
"end_line": 808,
"start_col": 2,
"start_line": 806
} |
Prims.Tot | val mk_selector_vprop_sel
(#t: Type0) (p: t -> vprop) (p_inj: interp_hp_of_injective p)
: Tot (selector t (mk_selector_vprop_hp p)) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mk_selector_vprop_sel
#t p p_inj
=
let varrayp_sel_depends_only_on
(#t: Type)
(p: t -> vprop)
(p_inj: interp_hp_of_injective p)
(m0: Steel.Memory.hmem (mk_selector_vprop_hp p))
(m1: mem { disjoint m0 m1 })
: Lemma
(
mk_selector_vprop_sel' p p_inj m0 == mk_selector_vprop_sel' p p_inj (Steel.Memory.join m0 m1)
)
[SMTPat (mk_selector_vprop_sel' p p_inj (Steel.Memory.join m0 m1))]
= p_inj (mk_selector_vprop_sel' p p_inj m0) (mk_selector_vprop_sel' p p_inj (Steel.Memory.join m0 m1)) (Steel.Memory.join m0 m1)
in
let varrayp_sel_depends_only_on_core
(#t: Type)
(p: t -> vprop)
(p_inj: interp_hp_of_injective p)
(m0: Steel.Memory.hmem (mk_selector_vprop_hp p))
: Lemma
(
mk_selector_vprop_sel' p p_inj m0 == mk_selector_vprop_sel' p p_inj (core_mem m0)
)
[SMTPat (mk_selector_vprop_sel' p p_inj (core_mem m0))]
= p_inj (mk_selector_vprop_sel' p p_inj m0) (mk_selector_vprop_sel' p p_inj (core_mem m0)) m0
in
mk_selector_vprop_sel' p p_inj | val mk_selector_vprop_sel
(#t: Type0) (p: t -> vprop) (p_inj: interp_hp_of_injective p)
: Tot (selector t (mk_selector_vprop_hp p))
let mk_selector_vprop_sel #t p p_inj = | false | null | false | let varrayp_sel_depends_only_on
(#t: Type)
(p: (t -> vprop))
(p_inj: interp_hp_of_injective p)
(m0: Steel.Memory.hmem (mk_selector_vprop_hp p))
(m1: mem{disjoint m0 m1})
: Lemma
(mk_selector_vprop_sel' p p_inj m0 == mk_selector_vprop_sel' p p_inj (Steel.Memory.join m0 m1)
) [SMTPat (mk_selector_vprop_sel' p p_inj (Steel.Memory.join m0 m1))] =
p_inj (mk_selector_vprop_sel' p p_inj m0)
(mk_selector_vprop_sel' p p_inj (Steel.Memory.join m0 m1))
(Steel.Memory.join m0 m1)
in
let varrayp_sel_depends_only_on_core
(#t: Type)
(p: (t -> vprop))
(p_inj: interp_hp_of_injective p)
(m0: Steel.Memory.hmem (mk_selector_vprop_hp p))
: Lemma (mk_selector_vprop_sel' p p_inj m0 == mk_selector_vprop_sel' p p_inj (core_mem m0))
[SMTPat (mk_selector_vprop_sel' p p_inj (core_mem m0))] =
p_inj (mk_selector_vprop_sel' p p_inj m0) (mk_selector_vprop_sel' p p_inj (core_mem m0)) m0
in
mk_selector_vprop_sel' p p_inj | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.interp_hp_of_injective",
"Steel.Effect.Atomic.mk_selector_vprop_sel'",
"Steel.Memory.hmem",
"Steel.Effect.Atomic.mk_selector_vprop_hp",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Steel.Memory.core_mem",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil",
"Steel.Memory.mem",
"Steel.Memory.disjoint",
"Steel.Memory.join",
"Steel.Effect.Common.selector"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p)
let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m)
let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m)
let witness_exists #a #u #p _ =
SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x)))
let lift_exists #a #u p =
as_atomic_action_ghost (Steel.Memory.lift_h_exists #u (fun x -> hp_of (p x)))
let exists_equiv p q =
Classical.forall_intro_2 reveal_equiv;
h_exists_cong (h_exists_sl' p) (h_exists_sl' q)
let exists_cong p q =
rewrite_slprop (h_exists p) (h_exists q)
(fun m ->
reveal_equiv (h_exists p) (h_exists q);
exists_equiv p q)
let fresh_invariant #uses p ctxt =
rewrite_slprop p (to_vprop (hp_of p)) (fun _ -> ());
let i = as_atomic_unobservable_action (fresh_invariant uses (hp_of p) ctxt) in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ());
return i
let new_invariant #uses p = let i = fresh_invariant #uses p [] in return i
(*
* AR: SteelAtomic and SteelGhost are not marked reifiable since we intend to run Steel programs natively
* However to implement the with_inv combinators we need to reify their thunks to reprs
* We could implement it better by having support for reification only in the .fst file
* But for now assuming a function
*)
assume val reify_steel_atomic_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames) (#g:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelAtomicBase a framed opened_invariants g pre post req ens)
: repr a framed opened_invariants g pre post req ens
[@@warn_on_use "as_unobservable_atomic_action is a trusted primitive"]
let as_atomic_o_action
(#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(o:observability)
(f:action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x))
= SteelAtomicBaseT?.reflect f
let with_invariant #a #fp #fp' #obs #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x = as_atomic_o_action obs
(Steel.Memory.with_invariant
#a
#(hp_of fp)
#(fun x -> hp_of (fp' x))
#opened
#(hp_of p)
i
(reify_steel_atomic_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return x
assume val reify_steel_ghost_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelGhostBase a framed opened_invariants Unobservable pre post req ens)
: repr a framed opened_invariants Unobservable pre post req ens
let with_invariant_g #a #fp #fp' #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x =
as_atomic_unobservable_action
(Steel.Memory.with_invariant #a #(hp_of fp) #(fun x -> hp_of (fp' x)) #opened #(hp_of p) i (reify_steel_ghost_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return (hide x)
let intro_vrefine v p =
let m = get () in
let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased (vrefine_t v p) = Ghost.hide (Ghost.reveal x) in
change_slprop
v
(vrefine v p)
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let elim_vrefine v p =
let h = get() in
let x : Ghost.erased (vrefine_t v p) = gget (vrefine v p) in
let x' : Ghost.erased (t_of v) = Ghost.hide (Ghost.reveal x) in
change_slprop
(vrefine v p)
v
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let vdep_cond
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
: Tot prop
= q == p (fst x1)
let vdep_rel
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
(x2: (t_of (vdep v p)))
: Tot prop
=
q == p (fst x1) /\
dfst (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == fst x1 /\
dsnd (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == snd x1
let intro_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (v `star` q)) m /\
q == p (fst (sel_of (v `star` q) m))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
))
=
Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m
let intro_vdep
v q p
=
reveal_star v q;
change_slprop_rel_with_cond
(v `star` q)
(vdep v p)
(vdep_cond v q p)
(vdep_rel v q p)
(fun m -> intro_vdep_lemma v q p m)
let vdep_cond_recip
(v: vprop)
(p: (t_of v -> Tot vprop))
(q: vprop)
(x2: t_of (vdep v p))
: Tot prop
= q == p (dfst (x2 <: dtuple2 (t_of v) (vdep_payload v p)))
let vdep_rel_recip
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x2: (t_of (vdep v p)))
(x1: t_of (v `star` q))
: Tot prop
=
vdep_rel v q p x1 x2
let elim_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (vdep v p)) m /\
q == p (dfst (sel_of (vdep v p) m <: dtuple2 (t_of v) (vdep_payload v p)))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
))
=
Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m
let elim_vdep0
(#opened:inames)
(v: vprop)
(p: (t_of v -> Tot vprop))
(q: vprop)
: SteelGhost unit opened
(vdep v p)
(fun _ -> v `star` q)
(requires (fun h -> q == p (dfst (h (vdep v p)))))
(ensures (fun h _ h' ->
let fs = h' v in
let sn = h' q in
let x2 = h (vdep v p) in
q == p fs /\
dfst x2 == fs /\
dsnd x2 == sn
))
= change_slprop_rel_with_cond
(vdep v p)
(v `star` q)
(vdep_cond_recip v p q)
(vdep_rel_recip v q p)
(fun m -> elim_vdep_lemma v q p m);
reveal_star v q
let elim_vdep
v p
= let r = gget (vdep v p) in
let res = Ghost.hide (dfst #(t_of v) #(vdep_payload v p) (Ghost.reveal r)) in
elim_vdep0 v p (p (Ghost.reveal res));
res
let intro_vrewrite
v #t f
= let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased t = Ghost.hide (f (Ghost.reveal x)) in
change_slprop
v
(vrewrite v f)
x
x'
(fun m ->
vrewrite_sel_eq v f m
)
let elim_vrewrite
v #t f
=
change_slprop_rel
(vrewrite v f)
v
(fun y x -> y == f x)
(fun m -> vrewrite_sel_eq v f m)
/// Deriving a selector-style vprop from an injective pts-to-style vprop
let hp_of_pointwise
(#t: Type)
(p: t -> vprop)
(x: t)
: Tot slprop
= hp_of (p x)
let mk_selector_vprop_hp
p
= Steel.Memory.h_exists (hp_of_pointwise p)
let mk_selector_vprop_sel'
(#t: Type)
(p: t -> vprop)
(p_inj: interp_hp_of_injective p) // unused in the definition, but necessary for the local SMTPats below
: Tot (selector' t (mk_selector_vprop_hp p))
= fun m -> id_elim_exists (hp_of_pointwise p) m
let mk_selector_vprop_sel | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mk_selector_vprop_sel
(#t: Type0) (p: t -> vprop) (p_inj: interp_hp_of_injective p)
: Tot (selector t (mk_selector_vprop_hp p)) | [] | Steel.Effect.Atomic.mk_selector_vprop_sel | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: (_: t -> Steel.Effect.Common.vprop) -> p_inj: Steel.Effect.Atomic.interp_hp_of_injective p
-> Steel.Effect.Common.selector t (Steel.Effect.Atomic.mk_selector_vprop_hp p) | {
"end_col": 32,
"end_line": 912,
"start_col": 1,
"start_line": 886
} |
Prims.Tot | val lift_atomic_steel
(a:Type)
(o:eqtype_as_type observability)
(#framed:eqtype_as_type bool)
(#[@@@ framing_implicit] pre:pre_t) (#[@@@ framing_implicit] post:post_t a)
(#[@@@ framing_implicit] req:req_t pre) (#[@@@ framing_implicit] ens:ens_t pre a post)
(f:repr a framed Set.empty o pre post req ens)
: Steel.Effect.repr a framed pre post req ens | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lift_atomic_steel a o f = f | val lift_atomic_steel
(a:Type)
(o:eqtype_as_type observability)
(#framed:eqtype_as_type bool)
(#[@@@ framing_implicit] pre:pre_t) (#[@@@ framing_implicit] post:post_t a)
(#[@@@ framing_implicit] req:req_t pre) (#[@@@ framing_implicit] ens:ens_t pre a post)
(f:repr a framed Set.empty o pre post req ens)
: Steel.Effect.repr a framed pre post req ens
let lift_atomic_steel a o f = | false | null | false | f | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"FStar.Pervasives.eqtype_as_type",
"Steel.Effect.Common.observability",
"Prims.bool",
"Steel.Effect.Common.pre_t",
"Steel.Effect.Common.post_t",
"Steel.Effect.Common.req_t",
"Steel.Effect.Common.ens_t",
"Steel.Effect.Atomic.repr",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.Effect.repr"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lift_atomic_steel
(a:Type)
(o:eqtype_as_type observability)
(#framed:eqtype_as_type bool)
(#[@@@ framing_implicit] pre:pre_t) (#[@@@ framing_implicit] post:post_t a)
(#[@@@ framing_implicit] req:req_t pre) (#[@@@ framing_implicit] ens:ens_t pre a post)
(f:repr a framed Set.empty o pre post req ens)
: Steel.Effect.repr a framed pre post req ens | [] | Steel.Effect.Atomic.lift_atomic_steel | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
a: Type ->
o: FStar.Pervasives.eqtype_as_type Steel.Effect.Common.observability ->
f: Steel.Effect.Atomic.repr a framed (FStar.Ghost.hide FStar.Set.empty) o pre post req ens
-> Steel.Effect.repr a framed pre post req ens | {
"end_col": 31,
"end_line": 353,
"start_col": 30,
"start_line": 353
} |
Steel.Effect.Atomic.SteelAtomicUT | val new_invariant (#opened_invariants:inames) (p:vprop)
: SteelAtomicUT (inv p) opened_invariants p (fun _ -> emp) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let new_invariant #uses p = let i = fresh_invariant #uses p [] in return i | val new_invariant (#opened_invariants:inames) (p:vprop)
: SteelAtomicUT (inv p) opened_invariants p (fun _ -> emp)
let new_invariant #uses p = | true | null | false | let i = fresh_invariant #uses p [] in
return i | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.return",
"Steel.Effect.Common.inv",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"Steel.Effect.Common.req",
"Steel.Effect.Common.rm",
"Steel.Effect.Atomic.fresh_inv",
"Prims.Nil",
"Steel.Memory.pre_inv",
"Steel.Effect.Atomic.fresh_invariant"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p)
let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m)
let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m)
let witness_exists #a #u #p _ =
SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x)))
let lift_exists #a #u p =
as_atomic_action_ghost (Steel.Memory.lift_h_exists #u (fun x -> hp_of (p x)))
let exists_equiv p q =
Classical.forall_intro_2 reveal_equiv;
h_exists_cong (h_exists_sl' p) (h_exists_sl' q)
let exists_cong p q =
rewrite_slprop (h_exists p) (h_exists q)
(fun m ->
reveal_equiv (h_exists p) (h_exists q);
exists_equiv p q)
let fresh_invariant #uses p ctxt =
rewrite_slprop p (to_vprop (hp_of p)) (fun _ -> ());
let i = as_atomic_unobservable_action (fresh_invariant uses (hp_of p) ctxt) in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ());
return i | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val new_invariant (#opened_invariants:inames) (p:vprop)
: SteelAtomicUT (inv p) opened_invariants p (fun _ -> emp) | [] | Steel.Effect.Atomic.new_invariant | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: Steel.Effect.Common.vprop -> Steel.Effect.Atomic.SteelAtomicUT (Steel.Effect.Common.inv p) | {
"end_col": 74,
"end_line": 639,
"start_col": 27,
"start_line": 639
} |
Steel.Effect.Atomic.SteelGhostT | val rewrite_slprop
(#opened:inames)
(p q:vprop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : SteelGhostT unit opened p (fun _ -> q) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l) | val rewrite_slprop
(#opened:inames)
(p q:vprop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : SteelGhostT unit opened p (fun _ -> q)
let rewrite_slprop p q l = | true | null | false | SteelGhost?.reflect (rewrite_slprop0 p q l) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Memory.mem",
"Prims.unit",
"Steel.Memory.interp",
"Steel.Effect.Common.hp_of",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Steel.Effect.Atomic.rewrite_slprop0"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val rewrite_slprop
(#opened:inames)
(p q:vprop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : SteelGhostT unit opened p (fun _ -> q) | [] | Steel.Effect.Atomic.rewrite_slprop | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
p: Steel.Effect.Common.vprop ->
q: Steel.Effect.Common.vprop ->
l:
(m: Steel.Memory.mem
-> FStar.Pervasives.Lemma (requires Steel.Memory.interp (Steel.Effect.Common.hp_of p) m)
(ensures Steel.Memory.interp (Steel.Effect.Common.hp_of q) m))
-> Steel.Effect.Atomic.SteelGhostT Prims.unit | {
"end_col": 70,
"end_line": 408,
"start_col": 27,
"start_line": 408
} |
FStar.Pervasives.Lemma | val intro_star
(p q: vprop)
(r: slprop)
(vp: erased (t_of p))
(vq: erased (t_of q))
(m: mem)
(proof:
(m: mem
-> Lemma (requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)))
: Lemma (requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m) | [
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro) | val intro_star
(p q: vprop)
(r: slprop)
(vp: erased (t_of p))
(vq: erased (t_of q))
(m: mem)
(proof:
(m: mem
-> Lemma (requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)))
: Lemma (requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
let intro_star
(p q: vprop)
(r: slprop)
(vp: erased (t_of p))
(vq: erased (t_of q))
(m: mem)
(proof:
(m: mem
-> Lemma (requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)))
: Lemma (requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m) = | false | null | true | let p = hp_of p in
let q = hp_of q in
let intro (ml mr: mem)
: Lemma (requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr)) =
Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"lemma"
] | [
"Steel.Effect.Common.vprop",
"Steel.Memory.slprop",
"FStar.Ghost.erased",
"Steel.Effect.Common.t_of",
"Steel.Memory.mem",
"Prims.unit",
"Prims.l_and",
"Steel.Memory.interp",
"Steel.Effect.Common.hp_of",
"Prims.eq2",
"Steel.Effect.Common.sel_of",
"FStar.Ghost.reveal",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"FStar.Classical.forall_intro_2",
"Prims.l_imp",
"Steel.Memory.disjoint",
"Steel.Memory.star",
"Steel.Memory.join",
"FStar.Classical.move_requires_2",
"FStar.Classical.forall_intro",
"FStar.Classical.move_requires",
"Steel.Memory.elim_star",
"Steel.Memory.intro_star"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val intro_star
(p q: vprop)
(r: slprop)
(vp: erased (t_of p))
(vq: erased (t_of q))
(m: mem)
(proof:
(m: mem
-> Lemma (requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)))
: Lemma (requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m) | [] | Steel.Effect.Atomic.intro_star | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
p: Steel.Effect.Common.vprop ->
q: Steel.Effect.Common.vprop ->
r: Steel.Memory.slprop ->
vp: FStar.Ghost.erased (Steel.Effect.Common.t_of p) ->
vq: FStar.Ghost.erased (Steel.Effect.Common.t_of q) ->
m: Steel.Memory.mem ->
proof:
(m: Steel.Memory.mem
-> FStar.Pervasives.Lemma
(requires
Steel.Memory.interp (Steel.Effect.Common.hp_of p) m /\
Steel.Effect.Common.sel_of p m == FStar.Ghost.reveal vp)
(ensures Steel.Memory.interp (Steel.Effect.Common.hp_of q) m))
-> FStar.Pervasives.Lemma
(requires
Steel.Memory.interp (Steel.Memory.star (Steel.Effect.Common.hp_of p) r) m /\
Steel.Effect.Common.sel_of p m == FStar.Ghost.reveal vp)
(ensures Steel.Memory.interp (Steel.Memory.star (Steel.Effect.Common.hp_of q) r) m) | {
"end_col": 60,
"end_line": 390,
"start_col": 1,
"start_line": 381
} |
Prims.Tot | val change_slprop0
(#opened: inames)
(p q: vprop)
(vp: erased (t_of p))
(vq: erased (t_of q))
(proof:
(m: mem
-> Lemma (requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)))
: repr unit
false
opened
Unobservable
p
(fun _ -> q)
(fun h -> h p == reveal vp)
(fun _ _ h1 -> h1 q == reveal vq) | [
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m) | val change_slprop0
(#opened: inames)
(p q: vprop)
(vp: erased (t_of p))
(vq: erased (t_of q))
(proof:
(m: mem
-> Lemma (requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)))
: repr unit
false
opened
Unobservable
p
(fun _ -> q)
(fun h -> h p == reveal vp)
(fun _ _ h1 -> h1 q == reveal vq)
let change_slprop0
(#opened: inames)
(p q: vprop)
(vp: erased (t_of p))
(vq: erased (t_of q))
(proof:
(m: mem
-> Lemma (requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)))
: repr unit
false
opened
Unobservable
p
(fun _ -> q)
(fun h -> h p == reveal vp)
(fun _ _ h1 -> h1 q == reveal vq) = | false | null | false | fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` (locks_invariant opened m)) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"FStar.Ghost.erased",
"Steel.Effect.Common.t_of",
"Steel.Memory.mem",
"Prims.unit",
"Prims.l_and",
"Steel.Memory.interp",
"Steel.Effect.Common.hp_of",
"Prims.eq2",
"Steel.Effect.Common.sel_of",
"FStar.Ghost.reveal",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Steel.Memory.slprop",
"Steel.Memory.star_associative",
"Steel.Memory.locks_invariant",
"Steel.Effect.Atomic.intro_star",
"Steel.Memory.star",
"FStar.Classical.forall_intro",
"Prims.l_imp",
"FStar.Classical.move_requires",
"Steel.Memory.core_mem",
"FStar.Classical.forall_intro_3",
"Steel.Effect.Common.hmem",
"Steel.Effect.Common.can_be_split",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.mk_rmem",
"Steel.Effect.Common.reveal_mk_rmem",
"Steel.Memory.full_mem",
"FStar.NMSTTotal.get",
"Steel.Memory.mem_evolves",
"Steel.Effect.Atomic.repr",
"Steel.Effect.Common.Unobservable",
"Steel.Effect.Common.rmem"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val change_slprop0
(#opened: inames)
(p q: vprop)
(vp: erased (t_of p))
(vq: erased (t_of q))
(proof:
(m: mem
-> Lemma (requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)))
: repr unit
false
opened
Unobservable
p
(fun _ -> q)
(fun h -> h p == reveal vp)
(fun _ _ h1 -> h1 q == reveal vq) | [] | Steel.Effect.Atomic.change_slprop0 | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
p: Steel.Effect.Common.vprop ->
q: Steel.Effect.Common.vprop ->
vp: FStar.Ghost.erased (Steel.Effect.Common.t_of p) ->
vq: FStar.Ghost.erased (Steel.Effect.Common.t_of q) ->
proof:
(m: Steel.Memory.mem
-> FStar.Pervasives.Lemma
(requires
Steel.Memory.interp (Steel.Effect.Common.hp_of p) m /\
Steel.Effect.Common.sel_of p m == FStar.Ghost.reveal vp)
(ensures
Steel.Memory.interp (Steel.Effect.Common.hp_of q) m /\
Steel.Effect.Common.sel_of q m == FStar.Ghost.reveal vq))
-> Steel.Effect.Atomic.repr Prims.unit
false
opened
Steel.Effect.Common.Unobservable
p
(fun _ -> q)
(fun h -> h p == FStar.Ghost.reveal vp)
(fun _ _ h1 -> h1 q == FStar.Ghost.reveal vq) | {
"end_col": 69,
"end_line": 423,
"start_col": 4,
"start_line": 416
} |
Steel.Effect.Atomic.SteelGhost | val noop (#opened:inames) (_:unit)
: SteelGhost unit opened emp (fun _ -> emp) (requires fun _ -> True) (ensures fun _ _ _ -> True) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ()) | val noop (#opened:inames) (_:unit)
: SteelGhost unit opened emp (fun _ -> emp) (requires fun _ -> True) (ensures fun _ _ _ -> True)
let noop _ = | true | null | false | change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ()) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Prims.unit",
"Steel.Effect.Atomic.change_slprop_rel",
"Steel.Effect.Common.emp",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_of",
"Prims.l_True",
"Prims.prop",
"Steel.Memory.mem"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val noop (#opened:inames) (_:unit)
: SteelGhost unit opened emp (fun _ -> emp) (requires fun _ -> True) (ensures fun _ _ _ -> True) | [] | Steel.Effect.Atomic.noop | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | _: Prims.unit -> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 70,
"end_line": 544,
"start_col": 13,
"start_line": 544
} |
Steel.Effect.Atomic.SteelGhostT | val as_atomic_action_ghost (#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(f:action_except a opened_invariants fp fp')
: SteelGhostT a opened_invariants (to_vprop fp) (fun x -> to_vprop (fp' x)) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let as_atomic_action_ghost f = SteelGhost?.reflect f | val as_atomic_action_ghost (#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(f:action_except a opened_invariants fp fp')
: SteelGhostT a opened_invariants (to_vprop fp) (fun x -> to_vprop (fp' x))
let as_atomic_action_ghost f = | true | null | false | SteelGhost?.reflect f | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Memory.slprop",
"Steel.Memory.action_except",
"Steel.Effect.Common.to_vprop",
"Steel.Effect.Common.vprop"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val as_atomic_action_ghost (#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(f:action_except a opened_invariants fp fp')
: SteelGhostT a opened_invariants (to_vprop fp) (fun x -> to_vprop (fp' x)) | [] | Steel.Effect.Atomic.as_atomic_action_ghost | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | f: Steel.Memory.action_except a opened_invariants fp fp' -> Steel.Effect.Atomic.SteelGhostT a | {
"end_col": 52,
"end_line": 356,
"start_col": 31,
"start_line": 356
} |
Prims.Tot | val extract_info0
(#opened: inames)
(p: vprop)
(vp: erased (normal (t_of p)))
(fact: prop)
(l: (m: mem -> Lemma (requires interp (hp_of p) m /\ sel_of p m == reveal vp) (ensures fact)))
: repr unit
false
opened
Unobservable
p
(fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact) | [
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0) | val extract_info0
(#opened: inames)
(p: vprop)
(vp: erased (normal (t_of p)))
(fact: prop)
(l: (m: mem -> Lemma (requires interp (hp_of p) m /\ sel_of p m == reveal vp) (ensures fact)))
: repr unit
false
opened
Unobservable
p
(fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
let extract_info0
(#opened: inames)
(p: vprop)
(vp: erased (normal (t_of p)))
(fact: prop)
(l: (m: mem -> Lemma (requires interp (hp_of p) m /\ sel_of p m == reveal vp) (ensures fact)))
: repr unit
false
opened
Unobservable
p
(fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact) = | false | null | false | fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"FStar.Ghost.erased",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_of",
"Prims.prop",
"Steel.Memory.mem",
"Prims.unit",
"Prims.l_and",
"Steel.Memory.interp",
"Steel.Effect.Common.hp_of",
"Prims.eq2",
"Steel.Effect.Common.sel_of",
"FStar.Ghost.reveal",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Steel.Memory.slprop",
"Steel.Memory.core_mem",
"Steel.Effect.lemma_frame_equalities_refl",
"Steel.Effect.Common.rmem'",
"Steel.Effect.Common.valid_rmem",
"Steel.Effect.Common.mk_rmem",
"FStar.Classical.forall_intro_3",
"Steel.Effect.Common.hmem",
"Steel.Effect.Common.can_be_split",
"Steel.Effect.Common.reveal_mk_rmem",
"Steel.Memory.full_mem",
"FStar.NMSTTotal.get",
"Steel.Memory.mem_evolves",
"Steel.Effect.Atomic.repr",
"Steel.Effect.Common.Unobservable",
"Steel.Effect.Common.rmem",
"Steel.Effect.Common.frame_equalities"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val extract_info0
(#opened: inames)
(p: vprop)
(vp: erased (normal (t_of p)))
(fact: prop)
(l: (m: mem -> Lemma (requires interp (hp_of p) m /\ sel_of p m == reveal vp) (ensures fact)))
: repr unit
false
opened
Unobservable
p
(fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact) | [] | Steel.Effect.Atomic.extract_info0 | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
p: Steel.Effect.Common.vprop ->
vp: FStar.Ghost.erased (Steel.Effect.Common.normal (Steel.Effect.Common.t_of p)) ->
fact: Prims.prop ->
l:
(m: Steel.Memory.mem
-> FStar.Pervasives.Lemma
(requires
Steel.Memory.interp (Steel.Effect.Common.hp_of p) m /\
Steel.Effect.Common.sel_of p m == FStar.Ghost.reveal vp) (ensures fact))
-> Steel.Effect.Atomic.repr Prims.unit
false
opened
Steel.Effect.Common.Unobservable
p
(fun _ -> p)
(fun h -> h p == FStar.Ghost.reveal vp)
(fun h0 _ h1 -> Steel.Effect.Common.frame_equalities p h0 h1 /\ fact) | {
"end_col": 21,
"end_line": 525,
"start_col": 4,
"start_line": 519
} |
Steel.Effect.Atomic.SteelGhostT | val witness_exists (#a:Type) (#opened_invariants:_) (#p:a -> vprop) (_:unit)
: SteelGhostT (erased a) opened_invariants
(h_exists p) (fun x -> p x) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let witness_exists #a #u #p _ =
SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x))) | val witness_exists (#a:Type) (#opened_invariants:_) (#p:a -> vprop) (_:unit)
: SteelGhostT (erased a) opened_invariants
(h_exists p) (fun x -> p x)
let witness_exists #a #u #p _ = | true | null | false | SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x))) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Prims.unit",
"Steel.Memory.witness_h_exists",
"Steel.Effect.Common.hp_of",
"Steel.Memory.slprop",
"FStar.Ghost.erased",
"Steel.Effect.Atomic.h_exists",
"FStar.Ghost.reveal"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p)
let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m)
let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val witness_exists (#a:Type) (#opened_invariants:_) (#p:a -> vprop) (_:unit)
: SteelGhostT (erased a) opened_invariants
(h_exists p) (fun x -> p x) | [] | Steel.Effect.Atomic.witness_exists | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | _: Prims.unit -> Steel.Effect.Atomic.SteelGhostT (FStar.Ghost.erased a) | {
"end_col": 79,
"end_line": 618,
"start_col": 2,
"start_line": 618
} |
Prims.Tot | val req_to_act_req (#pre: vprop) (req: req_t pre) : mprop (hp_of pre) | [
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m) | val req_to_act_req (#pre: vprop) (req: req_t pre) : mprop (hp_of pre)
let req_to_act_req (#pre: vprop) (req: req_t pre) : mprop (hp_of pre) = | false | null | false | fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.req_t",
"Steel.Memory.mem",
"Prims.l_and",
"Steel.Memory.interp",
"Steel.Effect.Common.hp_of",
"Steel.Effect.Common.mk_rmem",
"Prims.unit",
"Steel.Effect.rmem_depends_only_on",
"Prims.prop",
"Steel.Memory.mprop"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val req_to_act_req (#pre: vprop) (req: req_t pre) : mprop (hp_of pre) | [] | Steel.Effect.Atomic.req_to_act_req | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | req: Steel.Effect.Common.req_t pre -> Steel.Memory.mprop (Steel.Effect.Common.hp_of pre) | {
"end_col": 47,
"end_line": 30,
"start_col": 2,
"start_line": 28
} |
FStar.Pervasives.Lemma | val equiv_middle_left_assoc (a b c d: slprop)
: Lemma
((((a `Mem.star` b) `Mem.star` c) `Mem.star` d)
`Mem.equiv`
((a `Mem.star` (b `Mem.star` c)) `Mem.star` d)) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d | val equiv_middle_left_assoc (a b c d: slprop)
: Lemma
((((a `Mem.star` b) `Mem.star` c) `Mem.star` d)
`Mem.equiv`
((a `Mem.star` (b `Mem.star` c)) `Mem.star` d))
let equiv_middle_left_assoc (a b c d: slprop)
: Lemma
((((a `Mem.star` b) `Mem.star` c) `Mem.star` d)
`Mem.equiv`
((a `Mem.star` (b `Mem.star` c)) `Mem.star` d)) = | false | null | true | let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"lemma"
] | [
"Steel.Memory.slprop",
"Steel.Memory.star_congruence",
"Steel.Memory.star",
"Prims.unit",
"Steel.Memory.star_associative",
"Prims.l_True",
"Prims.squash",
"Steel.Memory.equiv",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv` | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val equiv_middle_left_assoc (a b c d: slprop)
: Lemma
((((a `Mem.star` b) `Mem.star` c) `Mem.star` d)
`Mem.equiv`
((a `Mem.star` (b `Mem.star` c)) `Mem.star` d)) | [] | Steel.Effect.Atomic.equiv_middle_left_assoc | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | a: Steel.Memory.slprop -> b: Steel.Memory.slprop -> c: Steel.Memory.slprop -> d: Steel.Memory.slprop
-> FStar.Pervasives.Lemma
(ensures
Steel.Memory.equiv (Steel.Memory.star (Steel.Memory.star (Steel.Memory.star a b) c) d)
(Steel.Memory.star (Steel.Memory.star a (Steel.Memory.star b c)) d)) | {
"end_col": 71,
"end_line": 82,
"start_col": 4,
"start_line": 80
} |
Steel.Effect.Atomic.SteelGhost | val change_slprop_2 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : SteelGhost unit opened p (fun _ -> q) (fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l) | val change_slprop_2 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : SteelGhost unit opened p (fun _ -> q) (fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
let change_slprop_2 p q vq l = | true | null | false | SteelGhost?.reflect (change_slprop_20 p q vq l) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"FStar.Ghost.erased",
"Steel.Effect.Common.t_of",
"Steel.Memory.mem",
"Prims.unit",
"Steel.Memory.interp",
"Steel.Effect.Common.hp_of",
"Prims.squash",
"Prims.l_and",
"Prims.eq2",
"Steel.Effect.Common.sel_of",
"FStar.Ghost.reveal",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Steel.Effect.Atomic.change_slprop_20",
"Steel.Effect.Common.rmem",
"Prims.l_True",
"Steel.Effect.Common.normal"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val change_slprop_2 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : SteelGhost unit opened p (fun _ -> q) (fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq) | [] | Steel.Effect.Atomic.change_slprop_2 | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
p: Steel.Effect.Common.vprop ->
q: Steel.Effect.Common.vprop ->
vq: FStar.Ghost.erased (Steel.Effect.Common.t_of q) ->
l:
(m: Steel.Memory.mem
-> FStar.Pervasives.Lemma (requires Steel.Memory.interp (Steel.Effect.Common.hp_of p) m)
(ensures
Steel.Memory.interp (Steel.Effect.Common.hp_of q) m /\
Steel.Effect.Common.sel_of q m == FStar.Ghost.reveal vq))
-> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 78,
"end_line": 457,
"start_col": 31,
"start_line": 457
} |
Steel.Effect.Atomic.SteelGhost | val extract_info (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : SteelGhost unit opened p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l) | val extract_info (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : SteelGhost unit opened p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
let extract_info p vp fact l = | true | null | false | SteelGhost?.reflect (extract_info0 p vp fact l) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"FStar.Ghost.erased",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_of",
"Prims.prop",
"Steel.Memory.mem",
"Prims.unit",
"Prims.l_and",
"Steel.Memory.interp",
"Steel.Effect.Common.hp_of",
"Prims.eq2",
"Steel.Effect.Common.sel_of",
"FStar.Ghost.reveal",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Steel.Effect.Atomic.extract_info0",
"Steel.Effect.Common.rmem",
"Steel.Effect.Common.frame_equalities"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val extract_info (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : SteelGhost unit opened p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact) | [] | Steel.Effect.Atomic.extract_info | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
p: Steel.Effect.Common.vprop ->
vp: FStar.Ghost.erased (Steel.Effect.Common.normal (Steel.Effect.Common.t_of p)) ->
fact: Prims.prop ->
l:
(m: Steel.Memory.mem
-> FStar.Pervasives.Lemma
(requires
Steel.Memory.interp (Steel.Effect.Common.hp_of p) m /\
Steel.Effect.Common.sel_of p m == FStar.Ghost.reveal vp) (ensures fact))
-> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 78,
"end_line": 527,
"start_col": 31,
"start_line": 527
} |
Steel.Effect.Atomic.SteelGhostT | val intro_exists (#a:Type) (#opened_invariants:_) (x:a) (p:a -> vprop)
: SteelGhostT unit opened_invariants (p x) (fun _ -> h_exists p) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m) | val intro_exists (#a:Type) (#opened_invariants:_) (x:a) (p:a -> vprop)
: SteelGhostT unit opened_invariants (p x) (fun _ -> h_exists p)
let intro_exists #a #opened x p = | true | null | false | rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.Effect.Atomic.h_exists",
"Steel.Memory.mem",
"Steel.Memory.intro_h_exists",
"Steel.Effect.Atomic.h_exists_sl'",
"Prims.unit"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val intro_exists (#a:Type) (#opened_invariants:_) (x:a) (p:a -> vprop)
: SteelGhostT unit opened_invariants (p x) (fun _ -> h_exists p) | [] | Steel.Effect.Atomic.intro_exists | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | x: a -> p: (_: a -> Steel.Effect.Common.vprop) -> Steel.Effect.Atomic.SteelGhostT Prims.unit | {
"end_col": 95,
"end_line": 611,
"start_col": 2,
"start_line": 611
} |
Prims.Tot | val change_slprop_rel0
(#opened: inames)
(p q: vprop)
(rel: (normal (t_of p) -> normal (t_of q) -> prop))
(proof:
(m: mem
-> Lemma (requires interp (hp_of p) m)
(ensures interp (hp_of p) m /\ interp (hp_of q) m /\ rel (sel_of p m) (sel_of q m)
)))
: repr unit
false
opened
Unobservable
p
(fun _ -> q)
(fun _ -> True)
(fun h0 _ h1 -> rel (h0 p) (h1 q)) | [
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m) | val change_slprop_rel0
(#opened: inames)
(p q: vprop)
(rel: (normal (t_of p) -> normal (t_of q) -> prop))
(proof:
(m: mem
-> Lemma (requires interp (hp_of p) m)
(ensures interp (hp_of p) m /\ interp (hp_of q) m /\ rel (sel_of p m) (sel_of q m)
)))
: repr unit
false
opened
Unobservable
p
(fun _ -> q)
(fun _ -> True)
(fun h0 _ h1 -> rel (h0 p) (h1 q))
let change_slprop_rel0
(#opened: inames)
(p q: vprop)
(rel: (normal (t_of p) -> normal (t_of q) -> prop))
(proof:
(m: mem
-> Lemma (requires interp (hp_of p) m)
(ensures interp (hp_of p) m /\ interp (hp_of q) m /\ rel (sel_of p m) (sel_of q m)
)))
: repr unit
false
opened
Unobservable
p
(fun _ -> q)
(fun _ -> True)
(fun h0 _ h1 -> rel (h0 p) (h1 q)) = | false | null | false | fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p
q
(frame `Mem.star` (locks_invariant opened m))
(sel_of p (core_mem m))
(sel_of q (core_mem m))
m
proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_of",
"Prims.prop",
"Steel.Memory.mem",
"Prims.unit",
"Steel.Memory.interp",
"Steel.Effect.Common.hp_of",
"Prims.squash",
"Prims.l_and",
"Steel.Effect.Common.sel_of",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Steel.Memory.slprop",
"Steel.Memory.star_associative",
"Steel.Memory.locks_invariant",
"Steel.Effect.Atomic.intro_star",
"Steel.Memory.star",
"FStar.Ghost.hide",
"Steel.Memory.core_mem",
"Steel.Effect.Common.reveal_mk_rmem",
"Steel.Effect.Common.rmem'",
"Steel.Effect.Common.valid_rmem",
"Steel.Effect.Common.mk_rmem",
"FStar.Classical.forall_intro_3",
"Steel.Effect.Common.hmem",
"Steel.Effect.Common.can_be_split",
"Prims.eq2",
"Steel.Memory.full_mem",
"FStar.NMSTTotal.get",
"Steel.Memory.mem_evolves",
"Steel.Effect.Atomic.repr",
"Steel.Effect.Common.Unobservable",
"Steel.Effect.Common.rmem",
"Prims.l_True"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val change_slprop_rel0
(#opened: inames)
(p q: vprop)
(rel: (normal (t_of p) -> normal (t_of q) -> prop))
(proof:
(m: mem
-> Lemma (requires interp (hp_of p) m)
(ensures interp (hp_of p) m /\ interp (hp_of q) m /\ rel (sel_of p m) (sel_of q m)
)))
: repr unit
false
opened
Unobservable
p
(fun _ -> q)
(fun _ -> True)
(fun h0 _ h1 -> rel (h0 p) (h1 q)) | [] | Steel.Effect.Atomic.change_slprop_rel0 | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
p: Steel.Effect.Common.vprop ->
q: Steel.Effect.Common.vprop ->
rel:
(
_: Steel.Effect.Common.normal (Steel.Effect.Common.t_of p) ->
_: Steel.Effect.Common.normal (Steel.Effect.Common.t_of q)
-> Prims.prop) ->
proof:
(m: Steel.Memory.mem
-> FStar.Pervasives.Lemma (requires Steel.Memory.interp (Steel.Effect.Common.hp_of p) m)
(ensures
Steel.Memory.interp (Steel.Effect.Common.hp_of p) m /\
Steel.Memory.interp (Steel.Effect.Common.hp_of q) m /\
rel (Steel.Effect.Common.sel_of p m) (Steel.Effect.Common.sel_of q m)))
-> Steel.Effect.Atomic.repr Prims.unit
false
opened
Steel.Effect.Common.Unobservable
p
(fun _ -> q)
(fun _ -> Prims.l_True)
(fun h0 _ h1 -> rel (h0 p) (h1 q)) | {
"end_col": 69,
"end_line": 480,
"start_col": 4,
"start_line": 469
} |
Steel.Effect.Atomic.SteelGhost | val change_slprop_rel_with_cond (#opened:inames)
(p q:vprop)
(cond: (t_of p) -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : SteelGhost unit opened p (fun _ -> q) (fun h0 -> cond (h0 p)) (fun h0 _ h1 -> rel (h0 p) (h1 q)) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof) | val change_slprop_rel_with_cond (#opened:inames)
(p q:vprop)
(cond: (t_of p) -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : SteelGhost unit opened p (fun _ -> q) (fun h0 -> cond (h0 p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
let change_slprop_rel_with_cond p q cond rel proof = | true | null | false | SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.t_of",
"Prims.prop",
"Steel.Memory.mem",
"Prims.unit",
"Prims.l_and",
"Steel.Memory.interp",
"Steel.Effect.Common.hp_of",
"Steel.Effect.Common.sel_of",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Steel.Effect.Atomic.change_slprop_rel_with_cond0",
"Steel.Effect.Common.rmem"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val change_slprop_rel_with_cond (#opened:inames)
(p q:vprop)
(cond: (t_of p) -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : SteelGhost unit opened p (fun _ -> q) (fun h0 -> cond (h0 p)) (fun h0 _ h1 -> rel (h0 p) (h1 q)) | [] | Steel.Effect.Atomic.change_slprop_rel_with_cond | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
p: Steel.Effect.Common.vprop ->
q: Steel.Effect.Common.vprop ->
cond: (_: Steel.Effect.Common.t_of p -> Prims.prop) ->
rel: (_: Steel.Effect.Common.t_of p -> _: Steel.Effect.Common.t_of q -> Prims.prop) ->
l:
(m: Steel.Memory.mem
-> FStar.Pervasives.Lemma
(requires
Steel.Memory.interp (Steel.Effect.Common.hp_of p) m /\
cond (Steel.Effect.Common.sel_of p m))
(ensures
Steel.Memory.interp (Steel.Effect.Common.hp_of q) m /\
rel (Steel.Effect.Common.sel_of p m) (Steel.Effect.Common.sel_of q m)))
-> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 73,
"end_line": 510,
"start_col": 4,
"start_line": 510
} |
Steel.Effect.Atomic.SteelGhostT | val drop (#opened:inames) (p:vprop) : SteelGhostT unit opened p (fun _ -> emp) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp()) | val drop (#opened:inames) (p:vprop) : SteelGhostT unit opened p (fun _ -> emp)
let drop p = | true | null | false | rewrite_slprop p
emp
(fun m ->
emp_unit (hp_of p);
affine_star (hp_of p) Mem.emp m;
reveal_emp ()) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.Effect.Common.emp",
"Steel.Memory.mem",
"Steel.Effect.Common.reveal_emp",
"Prims.unit",
"Steel.Memory.affine_star",
"Steel.Effect.Common.hp_of",
"Steel.Memory.emp",
"Steel.Memory.emp_unit"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val drop (#opened:inames) (p:vprop) : SteelGhostT unit opened p (fun _ -> emp) | [] | Steel.Effect.Atomic.drop | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: Steel.Effect.Common.vprop -> Steel.Effect.Atomic.SteelGhostT Prims.unit | {
"end_col": 78,
"end_line": 560,
"start_col": 13,
"start_line": 559
} |
Steel.Effect.Atomic.SteelGhost | val change_slprop
(#opened:inames)
(p q:vprop) (vp:erased (normal (t_of p))) (vq:erased (normal (t_of q)))
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : SteelGhost unit opened p (fun _ -> q)
(fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l) | val change_slprop
(#opened:inames)
(p q:vprop) (vp:erased (normal (t_of p))) (vq:erased (normal (t_of q)))
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : SteelGhost unit opened p (fun _ -> q)
(fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
let change_slprop p q vp vq l = | true | null | false | SteelGhost?.reflect (change_slprop0 p q vp vq l) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"FStar.Ghost.erased",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_of",
"Steel.Memory.mem",
"Prims.unit",
"Prims.l_and",
"Steel.Memory.interp",
"Steel.Effect.Common.hp_of",
"Prims.eq2",
"Steel.Effect.Common.sel_of",
"FStar.Ghost.reveal",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Steel.Effect.Atomic.change_slprop0",
"Steel.Effect.Common.rmem"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val change_slprop
(#opened:inames)
(p q:vprop) (vp:erased (normal (t_of p))) (vq:erased (normal (t_of q)))
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : SteelGhost unit opened p (fun _ -> q)
(fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq) | [] | Steel.Effect.Atomic.change_slprop | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
p: Steel.Effect.Common.vprop ->
q: Steel.Effect.Common.vprop ->
vp: FStar.Ghost.erased (Steel.Effect.Common.normal (Steel.Effect.Common.t_of p)) ->
vq: FStar.Ghost.erased (Steel.Effect.Common.normal (Steel.Effect.Common.t_of q)) ->
l:
(m: Steel.Memory.mem
-> FStar.Pervasives.Lemma
(requires
Steel.Memory.interp (Steel.Effect.Common.hp_of p) m /\
Steel.Effect.Common.sel_of p m == FStar.Ghost.reveal vp)
(ensures
Steel.Memory.interp (Steel.Effect.Common.hp_of q) m /\
Steel.Effect.Common.sel_of q m == FStar.Ghost.reveal vq))
-> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 81,
"end_line": 426,
"start_col": 33,
"start_line": 426
} |
Steel.Effect.Atomic.SteelGhostT | val exists_cong (#a:_) (#u:_) (p:a -> vprop) (q:a -> vprop {forall x. equiv (p x) (q x) })
: SteelGhostT unit u
(h_exists p)
(fun _ -> h_exists q) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let exists_cong p q =
rewrite_slprop (h_exists p) (h_exists q)
(fun m ->
reveal_equiv (h_exists p) (h_exists q);
exists_equiv p q) | val exists_cong (#a:_) (#u:_) (p:a -> vprop) (q:a -> vprop {forall x. equiv (p x) (q x) })
: SteelGhostT unit u
(h_exists p)
(fun _ -> h_exists q)
let exists_cong p q = | true | null | false | rewrite_slprop (h_exists p)
(h_exists q)
(fun m ->
reveal_equiv (h_exists p) (h_exists q);
exists_equiv p q) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Prims.l_Forall",
"Steel.Effect.Common.equiv",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.Effect.Atomic.h_exists",
"Steel.Memory.mem",
"Steel.Effect.Atomic.exists_equiv",
"Prims.unit",
"Steel.Effect.Common.reveal_equiv"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p)
let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m)
let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m)
let witness_exists #a #u #p _ =
SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x)))
let lift_exists #a #u p =
as_atomic_action_ghost (Steel.Memory.lift_h_exists #u (fun x -> hp_of (p x)))
let exists_equiv p q =
Classical.forall_intro_2 reveal_equiv;
h_exists_cong (h_exists_sl' p) (h_exists_sl' q) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val exists_cong (#a:_) (#u:_) (p:a -> vprop) (q:a -> vprop {forall x. equiv (p x) (q x) })
: SteelGhostT unit u
(h_exists p)
(fun _ -> h_exists q) | [] | Steel.Effect.Atomic.exists_cong | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
p: (_: a -> Steel.Effect.Common.vprop) ->
q: (_: a -> Steel.Effect.Common.vprop){forall (x: a). Steel.Effect.Common.equiv (p x) (q x)}
-> Steel.Effect.Atomic.SteelGhostT Prims.unit | {
"end_col": 23,
"end_line": 631,
"start_col": 2,
"start_line": 628
} |
Steel.Effect.Atomic.SteelAtomicBaseT | val as_atomic_o_action
(#a: Type u#a)
(#opened_invariants: inames)
(#fp: slprop)
(#fp': (a -> slprop))
(o: observability)
(f: action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x)) | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let as_atomic_o_action
(#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(o:observability)
(f:action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x))
= SteelAtomicBaseT?.reflect f | val as_atomic_o_action
(#a: Type u#a)
(#opened_invariants: inames)
(#fp: slprop)
(#fp': (a -> slprop))
(o: observability)
(f: action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x))
let as_atomic_o_action
(#a: Type u#a)
(#opened_invariants: inames)
(#fp: slprop)
(#fp': (a -> slprop))
(o: observability)
(f: action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x)) = | true | null | false | SteelAtomicBaseT?.reflect f | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Memory.slprop",
"Steel.Effect.Common.observability",
"Steel.Memory.action_except",
"Steel.Effect.Common.to_vprop",
"Steel.Effect.Common.vprop"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p)
let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m)
let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m)
let witness_exists #a #u #p _ =
SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x)))
let lift_exists #a #u p =
as_atomic_action_ghost (Steel.Memory.lift_h_exists #u (fun x -> hp_of (p x)))
let exists_equiv p q =
Classical.forall_intro_2 reveal_equiv;
h_exists_cong (h_exists_sl' p) (h_exists_sl' q)
let exists_cong p q =
rewrite_slprop (h_exists p) (h_exists q)
(fun m ->
reveal_equiv (h_exists p) (h_exists q);
exists_equiv p q)
let fresh_invariant #uses p ctxt =
rewrite_slprop p (to_vprop (hp_of p)) (fun _ -> ());
let i = as_atomic_unobservable_action (fresh_invariant uses (hp_of p) ctxt) in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ());
return i
let new_invariant #uses p = let i = fresh_invariant #uses p [] in return i
(*
* AR: SteelAtomic and SteelGhost are not marked reifiable since we intend to run Steel programs natively
* However to implement the with_inv combinators we need to reify their thunks to reprs
* We could implement it better by having support for reification only in the .fst file
* But for now assuming a function
*)
assume val reify_steel_atomic_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames) (#g:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelAtomicBase a framed opened_invariants g pre post req ens)
: repr a framed opened_invariants g pre post req ens
[@@warn_on_use "as_unobservable_atomic_action is a trusted primitive"]
let as_atomic_o_action
(#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(o:observability)
(f:action_except a opened_invariants fp fp') | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val as_atomic_o_action
(#a: Type u#a)
(#opened_invariants: inames)
(#fp: slprop)
(#fp': (a -> slprop))
(o: observability)
(f: action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x)) | [] | Steel.Effect.Atomic.as_atomic_o_action | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | o: Steel.Effect.Common.observability -> f: Steel.Memory.action_except a opened_invariants fp fp'
-> Steel.Effect.Atomic.SteelAtomicBaseT a | {
"end_col": 31,
"end_line": 663,
"start_col": 4,
"start_line": 663
} |
Steel.Effect.Atomic.SteelGhost | val slassert (#opened_invariants:_) (p:vprop)
: SteelGhost unit opened_invariants p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 _ h1 -> frame_equalities p h0 h1) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let slassert p = SteelGhost?.reflect (slassert0 p) | val slassert (#opened_invariants:_) (p:vprop)
: SteelGhost unit opened_invariants p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 _ h1 -> frame_equalities p h0 h1)
let slassert p = | true | null | false | SteelGhost?.reflect (slassert0 p) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.slassert0",
"Prims.unit",
"Steel.Effect.Common.rmem",
"Prims.l_True",
"Steel.Effect.Common.frame_equalities"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0 | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val slassert (#opened_invariants:_) (p:vprop)
: SteelGhost unit opened_invariants p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 _ h1 -> frame_equalities p h0 h1) | [] | Steel.Effect.Atomic.slassert | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: Steel.Effect.Common.vprop -> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 50,
"end_line": 557,
"start_col": 17,
"start_line": 557
} |
Steel.Effect.Atomic.SteelAtomicT | val as_atomic_action (#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(f:action_except a opened_invariants fp fp')
: SteelAtomicT a opened_invariants (to_vprop fp) (fun x -> to_vprop (fp' x)) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let as_atomic_action f = SteelAtomic?.reflect f | val as_atomic_action (#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(f:action_except a opened_invariants fp fp')
: SteelAtomicT a opened_invariants (to_vprop fp) (fun x -> to_vprop (fp' x))
let as_atomic_action f = | true | null | false | SteelAtomic?.reflect f | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Memory.slprop",
"Steel.Memory.action_except",
"Steel.Effect.Common.to_vprop",
"Steel.Effect.Common.vprop"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val as_atomic_action (#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(f:action_except a opened_invariants fp fp')
: SteelAtomicT a opened_invariants (to_vprop fp) (fun x -> to_vprop (fp' x)) | [] | Steel.Effect.Atomic.as_atomic_action | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | f: Steel.Memory.action_except a opened_invariants fp fp' -> Steel.Effect.Atomic.SteelAtomicT a | {
"end_col": 47,
"end_line": 355,
"start_col": 25,
"start_line": 355
} |
Prims.Tot | val get0: #opened: inames -> #p: vprop -> unit
-> repr (erased (rmem p))
true
opened
Unobservable
p
(fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1) | [
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0 | val get0: #opened: inames -> #p: vprop -> unit
-> repr (erased (rmem p))
true
opened
Unobservable
p
(fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
let get0 (#opened: inames) (#p: vprop) (_: unit)
: repr (erased (rmem p))
true
opened
Unobservable
p
(fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1) = | false | null | false | fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0 | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Prims.unit",
"Steel.Memory.slprop",
"FStar.Ghost.hide",
"Steel.Effect.Common.rmem",
"Steel.Effect.lemma_frame_equalities_refl",
"Steel.Effect.Common.rmem'",
"Steel.Effect.Common.valid_rmem",
"Steel.Effect.Common.mk_rmem",
"Steel.Memory.core_mem",
"FStar.Ghost.erased",
"Steel.Memory.full_mem",
"FStar.NMSTTotal.get",
"Steel.Memory.mem_evolves",
"Steel.Effect.Atomic.repr",
"Steel.Effect.Common.Unobservable",
"Prims.l_True",
"Prims.l_and",
"Steel.Effect.Common.frame_equalities",
"FStar.Ghost.reveal"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val get0: #opened: inames -> #p: vprop -> unit
-> repr (erased (rmem p))
true
opened
Unobservable
p
(fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1) | [] | Steel.Effect.Atomic.get0 | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | _: Prims.unit
-> Steel.Effect.Atomic.repr (FStar.Ghost.erased (Steel.Effect.Common.rmem p))
true
opened
Steel.Effect.Common.Unobservable
p
(fun _ -> p)
(fun _ -> Prims.l_True)
(fun h0 r h1 ->
Steel.Effect.Common.frame_equalities p h0 h1 /\
Steel.Effect.Common.frame_equalities p (FStar.Ghost.reveal r) h1) | {
"end_col": 8,
"end_line": 369,
"start_col": 4,
"start_line": 365
} |
Steel.Effect.Atomic.SteelAtomicUT | val as_atomic_unobservable_action
(#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(f:action_except a opened_invariants fp fp')
: SteelAtomicUT a opened_invariants (to_vprop fp) (fun x -> to_vprop (fp' x)) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let as_atomic_unobservable_action f = SteelAtomicU?.reflect f | val as_atomic_unobservable_action
(#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(f:action_except a opened_invariants fp fp')
: SteelAtomicUT a opened_invariants (to_vprop fp) (fun x -> to_vprop (fp' x))
let as_atomic_unobservable_action f = | true | null | false | SteelAtomicU?.reflect f | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Memory.slprop",
"Steel.Memory.action_except",
"Steel.Effect.Common.to_vprop",
"Steel.Effect.Common.vprop"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val as_atomic_unobservable_action
(#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(f:action_except a opened_invariants fp fp')
: SteelAtomicUT a opened_invariants (to_vprop fp) (fun x -> to_vprop (fp' x)) | [] | Steel.Effect.Atomic.as_atomic_unobservable_action | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | f: Steel.Memory.action_except a opened_invariants fp fp' -> Steel.Effect.Atomic.SteelAtomicUT a | {
"end_col": 61,
"end_line": 357,
"start_col": 38,
"start_line": 357
} |
Prims.Tot | val change_slprop_20
(#opened: inames)
(p q: vprop)
(vq: erased (t_of q))
(proof:
(m: mem
-> Lemma (requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)))
: repr unit
false
opened
Unobservable
p
(fun _ -> q)
(fun _ -> True)
(fun _ _ h1 -> h1 q == reveal vq) | [
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m) | val change_slprop_20
(#opened: inames)
(p q: vprop)
(vq: erased (t_of q))
(proof:
(m: mem
-> Lemma (requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)))
: repr unit
false
opened
Unobservable
p
(fun _ -> q)
(fun _ -> True)
(fun _ _ h1 -> h1 q == reveal vq)
let change_slprop_20
(#opened: inames)
(p q: vprop)
(vq: erased (t_of q))
(proof:
(m: mem
-> Lemma (requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)))
: repr unit
false
opened
Unobservable
p
(fun _ -> q)
(fun _ -> True)
(fun _ _ h1 -> h1 q == reveal vq) = | false | null | false | fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` (locks_invariant opened m)) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"FStar.Ghost.erased",
"Steel.Effect.Common.t_of",
"Steel.Memory.mem",
"Prims.unit",
"Steel.Memory.interp",
"Steel.Effect.Common.hp_of",
"Prims.squash",
"Prims.l_and",
"Prims.eq2",
"Steel.Effect.Common.sel_of",
"FStar.Ghost.reveal",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Steel.Memory.slprop",
"Steel.Memory.star_associative",
"Steel.Memory.locks_invariant",
"Steel.Effect.Atomic.intro_star",
"Steel.Memory.star",
"FStar.Ghost.hide",
"FStar.Classical.forall_intro",
"Prims.l_imp",
"FStar.Classical.move_requires",
"Steel.Memory.core_mem",
"FStar.Classical.forall_intro_3",
"Steel.Effect.Common.hmem",
"Steel.Effect.Common.can_be_split",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.mk_rmem",
"Steel.Effect.Common.reveal_mk_rmem",
"Steel.Memory.full_mem",
"FStar.NMSTTotal.get",
"Steel.Memory.mem_evolves",
"Steel.Effect.Atomic.repr",
"Steel.Effect.Common.Unobservable",
"Steel.Effect.Common.rmem",
"Prims.l_True"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val change_slprop_20
(#opened: inames)
(p q: vprop)
(vq: erased (t_of q))
(proof:
(m: mem
-> Lemma (requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)))
: repr unit
false
opened
Unobservable
p
(fun _ -> q)
(fun _ -> True)
(fun _ _ h1 -> h1 q == reveal vq) | [] | Steel.Effect.Atomic.change_slprop_20 | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
p: Steel.Effect.Common.vprop ->
q: Steel.Effect.Common.vprop ->
vq: FStar.Ghost.erased (Steel.Effect.Common.t_of q) ->
proof:
(m: Steel.Memory.mem
-> FStar.Pervasives.Lemma (requires Steel.Memory.interp (Steel.Effect.Common.hp_of p) m)
(ensures
Steel.Memory.interp (Steel.Effect.Common.hp_of q) m /\
Steel.Effect.Common.sel_of q m == FStar.Ghost.reveal vq))
-> Steel.Effect.Atomic.repr Prims.unit
false
opened
Steel.Effect.Common.Unobservable
p
(fun _ -> q)
(fun _ -> Prims.l_True)
(fun _ _ h1 -> h1 q == FStar.Ghost.reveal vq) | {
"end_col": 69,
"end_line": 454,
"start_col": 4,
"start_line": 447
} |
Steel.Effect.Atomic.SteelGhost | val reveal_star_3 (#opened:inames) (p1 p2 p3:vprop)
: SteelGhost unit opened (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3) | val reveal_star_3 (#opened:inames) (p1 p2 p3:vprop)
: SteelGhost unit opened (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
let reveal_star_3 p1 p2 p3 = | true | null | false | SteelGhost?.reflect (reveal_star_30 p1 p2 p3) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.reveal_star_30",
"Prims.unit",
"Steel.Effect.Common.star",
"Steel.Effect.Common.rmem",
"Prims.l_True",
"Prims.l_and",
"Steel.Effect.Common.can_be_split",
"Prims.eq2",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_of",
"FStar.Pervasives.Native.tuple2",
"Steel.Effect.Common.vprop'",
"Steel.Effect.Common.__proj__Mkvprop'__item__t",
"FStar.Pervasives.Native.Mktuple2"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3 | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val reveal_star_3 (#opened:inames) (p1 p2 p3:vprop)
: SteelGhost unit opened (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
) | [] | Steel.Effect.Atomic.reveal_star_3 | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p1: Steel.Effect.Common.vprop -> p2: Steel.Effect.Common.vprop -> p3: Steel.Effect.Common.vprop
-> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 74,
"end_line": 596,
"start_col": 29,
"start_line": 596
} |
Prims.Tot | val change_slprop_rel_with_cond0
(#opened: inames)
(p q: vprop)
(cond: (t_of p -> prop))
(rel: ((t_of p) -> (t_of q) -> prop))
(proof:
(m: mem
-> Lemma (requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures interp (hp_of p) m /\ interp (hp_of q) m /\ rel (sel_of p m) (sel_of q m)
)))
: repr unit
false
opened
Unobservable
p
(fun _ -> q)
(fun m -> cond (m p))
(fun h0 _ h1 -> rel (h0 p) (h1 q)) | [
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m) | val change_slprop_rel_with_cond0
(#opened: inames)
(p q: vprop)
(cond: (t_of p -> prop))
(rel: ((t_of p) -> (t_of q) -> prop))
(proof:
(m: mem
-> Lemma (requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures interp (hp_of p) m /\ interp (hp_of q) m /\ rel (sel_of p m) (sel_of q m)
)))
: repr unit
false
opened
Unobservable
p
(fun _ -> q)
(fun m -> cond (m p))
(fun h0 _ h1 -> rel (h0 p) (h1 q))
let change_slprop_rel_with_cond0
(#opened: inames)
(p q: vprop)
(cond: (t_of p -> prop))
(rel: ((t_of p) -> (t_of q) -> prop))
(proof:
(m: mem
-> Lemma (requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures interp (hp_of p) m /\ interp (hp_of q) m /\ rel (sel_of p m) (sel_of q m)
)))
: repr unit
false
opened
Unobservable
p
(fun _ -> q)
(fun m -> cond (m p))
(fun h0 _ h1 -> rel (h0 p) (h1 q)) = | false | null | false | fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p
q
(frame `Mem.star` (locks_invariant opened m))
(sel_of p (core_mem m))
(sel_of q (core_mem m))
m
proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.t_of",
"Prims.prop",
"Steel.Memory.mem",
"Prims.unit",
"Prims.l_and",
"Steel.Memory.interp",
"Steel.Effect.Common.hp_of",
"Steel.Effect.Common.sel_of",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Steel.Memory.slprop",
"Steel.Memory.star_associative",
"Steel.Memory.locks_invariant",
"Steel.Effect.Atomic.intro_star",
"Steel.Memory.star",
"FStar.Ghost.hide",
"Steel.Memory.core_mem",
"Steel.Effect.Common.reveal_mk_rmem",
"Steel.Effect.Common.rmem'",
"Steel.Effect.Common.valid_rmem",
"Steel.Effect.Common.mk_rmem",
"FStar.Classical.forall_intro_3",
"Steel.Effect.Common.hmem",
"Steel.Effect.Common.can_be_split",
"Prims.eq2",
"Steel.Effect.Common.normal",
"Steel.Memory.full_mem",
"FStar.NMSTTotal.get",
"Steel.Memory.mem_evolves",
"Steel.Effect.Atomic.repr",
"Steel.Effect.Common.Unobservable",
"Steel.Effect.Common.rmem"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val change_slprop_rel_with_cond0
(#opened: inames)
(p q: vprop)
(cond: (t_of p -> prop))
(rel: ((t_of p) -> (t_of q) -> prop))
(proof:
(m: mem
-> Lemma (requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures interp (hp_of p) m /\ interp (hp_of q) m /\ rel (sel_of p m) (sel_of q m)
)))
: repr unit
false
opened
Unobservable
p
(fun _ -> q)
(fun m -> cond (m p))
(fun h0 _ h1 -> rel (h0 p) (h1 q)) | [] | Steel.Effect.Atomic.change_slprop_rel_with_cond0 | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
p: Steel.Effect.Common.vprop ->
q: Steel.Effect.Common.vprop ->
cond: (_: Steel.Effect.Common.t_of p -> Prims.prop) ->
rel: (_: Steel.Effect.Common.t_of p -> _: Steel.Effect.Common.t_of q -> Prims.prop) ->
proof:
(m: Steel.Memory.mem
-> FStar.Pervasives.Lemma
(requires
Steel.Memory.interp (Steel.Effect.Common.hp_of p) m /\
cond (Steel.Effect.Common.sel_of p m))
(ensures
Steel.Memory.interp (Steel.Effect.Common.hp_of p) m /\
Steel.Memory.interp (Steel.Effect.Common.hp_of q) m /\
rel (Steel.Effect.Common.sel_of p m) (Steel.Effect.Common.sel_of q m)))
-> Steel.Effect.Atomic.repr Prims.unit
false
opened
Steel.Effect.Common.Unobservable
p
(fun _ -> q)
(fun m -> cond (m p))
(fun h0 _ h1 -> rel (h0 p) (h1 q)) | {
"end_col": 69,
"end_line": 507,
"start_col": 4,
"start_line": 495
} |
Steel.Effect.Atomic.SteelGhost | val change_slprop_rel (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : SteelGhost unit opened p (fun _ -> q) (fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q)) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof) | val change_slprop_rel (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : SteelGhost unit opened p (fun _ -> q) (fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
let change_slprop_rel p q rel proof = | true | null | false | SteelGhost?.reflect (change_slprop_rel0 p q rel proof) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_of",
"Prims.prop",
"Steel.Memory.mem",
"Prims.unit",
"Steel.Memory.interp",
"Steel.Effect.Common.hp_of",
"Prims.squash",
"Prims.l_and",
"Steel.Effect.Common.sel_of",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Steel.Effect.Atomic.change_slprop_rel0",
"Steel.Effect.Common.rmem",
"Prims.l_True"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val change_slprop_rel (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : SteelGhost unit opened p (fun _ -> q) (fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q)) | [] | Steel.Effect.Atomic.change_slprop_rel | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
p: Steel.Effect.Common.vprop ->
q: Steel.Effect.Common.vprop ->
rel:
(
_: Steel.Effect.Common.normal (Steel.Effect.Common.t_of p) ->
_: Steel.Effect.Common.normal (Steel.Effect.Common.t_of q)
-> Prims.prop) ->
l:
(m: Steel.Memory.mem
-> FStar.Pervasives.Lemma (requires Steel.Memory.interp (Steel.Effect.Common.hp_of p) m)
(ensures
Steel.Memory.interp (Steel.Effect.Common.hp_of q) m /\
rel (Steel.Effect.Common.sel_of p m) (Steel.Effect.Common.sel_of q m)))
-> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 92,
"end_line": 482,
"start_col": 38,
"start_line": 482
} |
Prims.Tot | val slassert0 (#opened: inames) (p: vprop)
: repr unit
false
opened
Unobservable
p
(fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1) | [
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0 | val slassert0 (#opened: inames) (p: vprop)
: repr unit
false
opened
Unobservable
p
(fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
let slassert0 (#opened: inames) (p: vprop)
: repr unit
false
opened
Unobservable
p
(fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1) = | false | null | false | fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0 | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Memory.slprop",
"Steel.Effect.lemma_frame_equalities_refl",
"Steel.Effect.Common.rmem'",
"Steel.Effect.Common.valid_rmem",
"Steel.Effect.Common.mk_rmem",
"Steel.Memory.core_mem",
"Prims.unit",
"Steel.Memory.full_mem",
"FStar.NMSTTotal.get",
"Steel.Memory.mem_evolves",
"Steel.Effect.Atomic.repr",
"Steel.Effect.Common.Unobservable",
"Steel.Effect.Common.rmem",
"Prims.l_True",
"Steel.Effect.Common.frame_equalities"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val slassert0 (#opened: inames) (p: vprop)
: repr unit
false
opened
Unobservable
p
(fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1) | [] | Steel.Effect.Atomic.slassert0 | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: Steel.Effect.Common.vprop
-> Steel.Effect.Atomic.repr Prims.unit
false
opened
Steel.Effect.Common.Unobservable
p
(fun _ -> p)
(fun _ -> Prims.l_True)
(fun h0 _ h1 -> Steel.Effect.Common.frame_equalities p h0 h1) | {
"end_col": 38,
"end_line": 555,
"start_col": 4,
"start_line": 552
} |
Prims.Tot | val bind_pure_steela_ (a:Type) (b:Type)
(opened_invariants:inames)
(o:eqtype_as_type observability)
(#[@@@ framing_implicit] wp:pure_wp a)
(#framed: eqtype_as_type bool)
(#[@@@ framing_implicit] pre:pre_t) (#[@@@ framing_implicit] post:post_t b)
(#[@@@ framing_implicit] req:a -> req_t pre) (#[@@@ framing_implicit] ens:a -> ens_t pre b post)
(f:eqtype_as_type unit -> PURE a wp)
(g:(x:a -> repr b framed opened_invariants o pre post (req x) (ens x)))
: repr b framed opened_invariants o
pre
post
(bind_pure_steel__req wp req)
(bind_pure_steel__ens wp ens) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame | val bind_pure_steela_ (a:Type) (b:Type)
(opened_invariants:inames)
(o:eqtype_as_type observability)
(#[@@@ framing_implicit] wp:pure_wp a)
(#framed: eqtype_as_type bool)
(#[@@@ framing_implicit] pre:pre_t) (#[@@@ framing_implicit] post:post_t b)
(#[@@@ framing_implicit] req:a -> req_t pre) (#[@@@ framing_implicit] ens:a -> ens_t pre b post)
(f:eqtype_as_type unit -> PURE a wp)
(g:(x:a -> repr b framed opened_invariants o pre post (req x) (ens x)))
: repr b framed opened_invariants o
pre
post
(bind_pure_steel__req wp req)
(bind_pure_steel__ens wp ens)
let bind_pure_steela_ a b opened o #wp f g = | false | null | false | FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Memory.inames",
"FStar.Pervasives.eqtype_as_type",
"Steel.Effect.Common.observability",
"Prims.pure_wp",
"Prims.bool",
"Steel.Effect.Common.pre_t",
"Steel.Effect.Common.post_t",
"Steel.Effect.Common.req_t",
"Steel.Effect.Common.ens_t",
"Prims.unit",
"Steel.Effect.Atomic.repr",
"Steel.Memory.slprop",
"FStar.Monotonic.Pure.elim_pure_wp_monotonicity",
"Steel.Effect.Atomic.bind_pure_steel__req",
"Steel.Effect.Atomic.bind_pure_steel__ens"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bind_pure_steela_ (a:Type) (b:Type)
(opened_invariants:inames)
(o:eqtype_as_type observability)
(#[@@@ framing_implicit] wp:pure_wp a)
(#framed: eqtype_as_type bool)
(#[@@@ framing_implicit] pre:pre_t) (#[@@@ framing_implicit] post:post_t b)
(#[@@@ framing_implicit] req:a -> req_t pre) (#[@@@ framing_implicit] ens:a -> ens_t pre b post)
(f:eqtype_as_type unit -> PURE a wp)
(g:(x:a -> repr b framed opened_invariants o pre post (req x) (ens x)))
: repr b framed opened_invariants o
pre
post
(bind_pure_steel__req wp req)
(bind_pure_steel__ens wp ens) | [] | Steel.Effect.Atomic.bind_pure_steela_ | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
a: Type ->
b: Type ->
opened_invariants: Steel.Memory.inames ->
o: FStar.Pervasives.eqtype_as_type Steel.Effect.Common.observability ->
f: (_: FStar.Pervasives.eqtype_as_type Prims.unit -> Prims.PURE a) ->
g: (x: a -> Steel.Effect.Atomic.repr b framed opened_invariants o pre post (req x) (ens x))
-> Steel.Effect.Atomic.repr b
framed
opened_invariants
o
pre
post
(Steel.Effect.Atomic.bind_pure_steel__req wp req)
(Steel.Effect.Atomic.bind_pure_steel__ens wp ens) | {
"end_col": 15,
"end_line": 349,
"start_col": 4,
"start_line": 346
} |
FStar.Pervasives.Lemma | val exists_equiv (#a:_) (p:a -> vprop) (q:a -> vprop {forall x. equiv (p x) (q x) })
: Lemma (h_exists p `equiv` h_exists q) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let exists_equiv p q =
Classical.forall_intro_2 reveal_equiv;
h_exists_cong (h_exists_sl' p) (h_exists_sl' q) | val exists_equiv (#a:_) (p:a -> vprop) (q:a -> vprop {forall x. equiv (p x) (q x) })
: Lemma (h_exists p `equiv` h_exists q)
let exists_equiv p q = | false | null | true | Classical.forall_intro_2 reveal_equiv;
h_exists_cong (h_exists_sl' p) (h_exists_sl' q) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"lemma"
] | [
"Steel.Effect.Common.vprop",
"Prims.l_Forall",
"Steel.Effect.Common.equiv",
"Steel.Memory.h_exists_cong",
"Steel.Effect.Atomic.h_exists_sl'",
"Prims.unit",
"FStar.Classical.forall_intro_2",
"Prims.l_iff",
"Steel.Memory.equiv",
"Steel.Effect.Common.hp_of",
"Steel.Effect.Common.reveal_equiv"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p)
let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m)
let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m)
let witness_exists #a #u #p _ =
SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x)))
let lift_exists #a #u p =
as_atomic_action_ghost (Steel.Memory.lift_h_exists #u (fun x -> hp_of (p x))) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val exists_equiv (#a:_) (p:a -> vprop) (q:a -> vprop {forall x. equiv (p x) (q x) })
: Lemma (h_exists p `equiv` h_exists q) | [] | Steel.Effect.Atomic.exists_equiv | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
p: (_: a -> Steel.Effect.Common.vprop) ->
q: (_: a -> Steel.Effect.Common.vprop){forall (x: a). Steel.Effect.Common.equiv (p x) (q x)}
-> FStar.Pervasives.Lemma
(ensures
Steel.Effect.Common.equiv (Steel.Effect.Atomic.h_exists p) (Steel.Effect.Atomic.h_exists q)) | {
"end_col": 49,
"end_line": 625,
"start_col": 2,
"start_line": 624
} |
Prims.Tot | val vdep_rel (v q: vprop) (p: (t_of v -> Tot vprop)) (x1: t_of (v `star` q)) (x2: (t_of (vdep v p)))
: Tot prop | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let vdep_rel
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
(x2: (t_of (vdep v p)))
: Tot prop
=
q == p (fst x1) /\
dfst (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == fst x1 /\
dsnd (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == snd x1 | val vdep_rel (v q: vprop) (p: (t_of v -> Tot vprop)) (x1: t_of (v `star` q)) (x2: (t_of (vdep v p)))
: Tot prop
let vdep_rel (v q: vprop) (p: (t_of v -> Tot vprop)) (x1: t_of (v `star` q)) (x2: (t_of (vdep v p)))
: Tot prop = | false | null | false | q == p (fst x1) /\ dfst (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == fst x1 /\
dsnd (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == snd x1 | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.t_of",
"Steel.Effect.Common.star",
"Steel.Effect.Common.vdep",
"Prims.l_and",
"Prims.eq2",
"FStar.Pervasives.Native.fst",
"FStar.Pervasives.dfst",
"Steel.Effect.Common.vdep_payload",
"Prims.dtuple2",
"FStar.Pervasives.dsnd",
"FStar.Pervasives.Native.snd",
"Prims.prop"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p)
let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m)
let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m)
let witness_exists #a #u #p _ =
SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x)))
let lift_exists #a #u p =
as_atomic_action_ghost (Steel.Memory.lift_h_exists #u (fun x -> hp_of (p x)))
let exists_equiv p q =
Classical.forall_intro_2 reveal_equiv;
h_exists_cong (h_exists_sl' p) (h_exists_sl' q)
let exists_cong p q =
rewrite_slprop (h_exists p) (h_exists q)
(fun m ->
reveal_equiv (h_exists p) (h_exists q);
exists_equiv p q)
let fresh_invariant #uses p ctxt =
rewrite_slprop p (to_vprop (hp_of p)) (fun _ -> ());
let i = as_atomic_unobservable_action (fresh_invariant uses (hp_of p) ctxt) in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ());
return i
let new_invariant #uses p = let i = fresh_invariant #uses p [] in return i
(*
* AR: SteelAtomic and SteelGhost are not marked reifiable since we intend to run Steel programs natively
* However to implement the with_inv combinators we need to reify their thunks to reprs
* We could implement it better by having support for reification only in the .fst file
* But for now assuming a function
*)
assume val reify_steel_atomic_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames) (#g:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelAtomicBase a framed opened_invariants g pre post req ens)
: repr a framed opened_invariants g pre post req ens
[@@warn_on_use "as_unobservable_atomic_action is a trusted primitive"]
let as_atomic_o_action
(#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(o:observability)
(f:action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x))
= SteelAtomicBaseT?.reflect f
let with_invariant #a #fp #fp' #obs #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x = as_atomic_o_action obs
(Steel.Memory.with_invariant
#a
#(hp_of fp)
#(fun x -> hp_of (fp' x))
#opened
#(hp_of p)
i
(reify_steel_atomic_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return x
assume val reify_steel_ghost_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelGhostBase a framed opened_invariants Unobservable pre post req ens)
: repr a framed opened_invariants Unobservable pre post req ens
let with_invariant_g #a #fp #fp' #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x =
as_atomic_unobservable_action
(Steel.Memory.with_invariant #a #(hp_of fp) #(fun x -> hp_of (fp' x)) #opened #(hp_of p) i (reify_steel_ghost_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return (hide x)
let intro_vrefine v p =
let m = get () in
let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased (vrefine_t v p) = Ghost.hide (Ghost.reveal x) in
change_slprop
v
(vrefine v p)
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let elim_vrefine v p =
let h = get() in
let x : Ghost.erased (vrefine_t v p) = gget (vrefine v p) in
let x' : Ghost.erased (t_of v) = Ghost.hide (Ghost.reveal x) in
change_slprop
(vrefine v p)
v
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let vdep_cond
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
: Tot prop
= q == p (fst x1)
let vdep_rel
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
(x2: (t_of (vdep v p)))
: Tot prop | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val vdep_rel (v q: vprop) (p: (t_of v -> Tot vprop)) (x1: t_of (v `star` q)) (x2: (t_of (vdep v p)))
: Tot prop | [] | Steel.Effect.Atomic.vdep_rel | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
v: Steel.Effect.Common.vprop ->
q: Steel.Effect.Common.vprop ->
p: (_: Steel.Effect.Common.t_of v -> Steel.Effect.Common.vprop) ->
x1: Steel.Effect.Common.t_of (Steel.Effect.Common.star v q) ->
x2: Steel.Effect.Common.t_of (Steel.Effect.Common.vdep v p)
-> Prims.prop | {
"end_col": 62,
"end_line": 739,
"start_col": 2,
"start_line": 737
} |
Prims.Tot | val reveal_star0 (#opened: inames) (p1 p2: vprop)
: repr unit
false
opened
Unobservable
(p1 `star` p2)
(fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)) | [
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem | val reveal_star0 (#opened: inames) (p1 p2: vprop)
: repr unit
false
opened
Unobservable
(p1 `star` p2)
(fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2))
let reveal_star0 (#opened: inames) (p1 p2: vprop)
: repr unit
false
opened
Unobservable
(p1 `star` p2)
(fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)) = | false | null | false | fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Memory.slprop",
"FStar.Classical.forall_intro_3",
"Steel.Effect.Common.hmem",
"Steel.Effect.Common.can_be_split",
"Prims.eq2",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_of",
"Steel.Effect.Common.mk_rmem",
"Steel.Effect.Common.sel_of",
"Steel.Effect.Common.reveal_mk_rmem",
"Prims.unit",
"Steel.Memory.full_mem",
"FStar.NMSTTotal.get",
"Steel.Memory.mem_evolves",
"Steel.Effect.Atomic.repr",
"Steel.Effect.Common.Unobservable",
"Steel.Effect.Common.star",
"Steel.Effect.Common.rmem",
"Prims.l_True",
"Prims.l_and",
"FStar.Pervasives.Native.tuple2",
"Steel.Effect.Common.vprop'",
"Steel.Effect.Common.__proj__Mkvprop'__item__t",
"FStar.Pervasives.Native.Mktuple2"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val reveal_star0 (#opened: inames) (p1 p2: vprop)
: repr unit
false
opened
Unobservable
(p1 `star` p2)
(fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)) | [] | Steel.Effect.Atomic.reveal_star0 | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p1: Steel.Effect.Common.vprop -> p2: Steel.Effect.Common.vprop
-> Steel.Effect.Atomic.repr Prims.unit
false
opened
Steel.Effect.Common.Unobservable
(Steel.Effect.Common.star p1 p2)
(fun _ -> Steel.Effect.Common.star p1 p2)
(fun _ -> Prims.l_True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (Steel.Effect.Common.star p1 p2) == FStar.Pervasives.Native.Mktuple2 (h0 p1) (h0 p2) /\
h1 (Steel.Effect.Common.star p1 p2) == FStar.Pervasives.Native.Mktuple2 (h1 p1) (h1 p2)) | {
"end_col": 44,
"end_line": 572,
"start_col": 3,
"start_line": 570
} |
Prims.Pure | val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x | val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque
a
opened
o1
o2
#framed_f
#framed_g
#pre_f
#post_f
#req_f
#ens_f
#pre_g
#post_g
#req_g
#ens_g
#fr
#pr
#_
#p1
#p2
f
= | false | null | false | fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem ((post_f x) `star` fr) (core_mem m1) in
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) ((post_f x) `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) ((post_f x) `star` fr) (post_f x);
can_be_split_trans (post_g x) ((post_f x) `star` fr) fr;
can_be_split_3_interp (hp_of ((post_f x) `star` fr))
(hp_of (post_g x))
frame
(locks_invariant opened m1)
m1;
focus_replace (post_g x) ((post_f x) `star` fr) (post_f x) (core_mem m1);
x | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"FStar.Pervasives.eqtype_as_type",
"Steel.Effect.Common.observability",
"Prims.bool",
"Steel.Effect.Common.pre_t",
"Steel.Effect.Common.post_t",
"Steel.Effect.Common.req_t",
"Steel.Effect.Common.ens_t",
"Steel.Effect.Common.vprop",
"Prims.prop",
"Prims.squash",
"Steel.Effect.Common.maybe_emp",
"Steel.Effect.Common.can_be_split_dep",
"Steel.Effect.Common.star",
"Steel.Effect.Common.equiv_forall",
"Steel.Effect.Atomic.repr",
"Steel.Memory.slprop",
"Prims.unit",
"Steel.Effect.focus_replace",
"Steel.Memory.core_mem",
"Steel.Effect.can_be_split_3_interp",
"Steel.Effect.Common.hp_of",
"Steel.Memory.locks_invariant",
"Steel.Effect.Common.can_be_split_trans",
"Prims._assert",
"Steel.Effect.frame_opaque",
"Steel.Effect.Common.focus_rmem",
"Steel.Effect.Common.rmem'",
"Steel.Effect.Common.valid_rmem",
"Steel.Effect.Common.mk_rmem",
"Steel.Memory.full_mem",
"FStar.NMSTTotal.get",
"Steel.Memory.mem_evolves",
"Steel.Effect.Atomic.frame00"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True) | [] | Steel.Effect.Atomic.subcomp_opaque | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
a: Type ->
opened: Steel.Memory.inames ->
o1: FStar.Pervasives.eqtype_as_type Steel.Effect.Common.observability ->
o2: FStar.Pervasives.eqtype_as_type Steel.Effect.Common.observability ->
f: Steel.Effect.Atomic.repr a framed_f opened o1 pre_f post_f req_f ens_f
-> Prims.Pure (Steel.Effect.Atomic.repr a framed_g opened o2 pre_g post_g req_g ens_g) | {
"end_col": 5,
"end_line": 337,
"start_col": 2,
"start_line": 305
} |
Prims.Tot | val mk_selector_vprop_sel' (#t: Type) (p: (t -> vprop)) (p_inj: interp_hp_of_injective p)
: Tot (selector' t (mk_selector_vprop_hp p)) | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mk_selector_vprop_sel'
(#t: Type)
(p: t -> vprop)
(p_inj: interp_hp_of_injective p) // unused in the definition, but necessary for the local SMTPats below
: Tot (selector' t (mk_selector_vprop_hp p))
= fun m -> id_elim_exists (hp_of_pointwise p) m | val mk_selector_vprop_sel' (#t: Type) (p: (t -> vprop)) (p_inj: interp_hp_of_injective p)
: Tot (selector' t (mk_selector_vprop_hp p))
let mk_selector_vprop_sel' (#t: Type) (p: (t -> vprop)) (p_inj: interp_hp_of_injective p)
: Tot (selector' t (mk_selector_vprop_hp p)) = | false | null | false | fun m -> id_elim_exists (hp_of_pointwise p) m | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.interp_hp_of_injective",
"Steel.Memory.hmem",
"Steel.Effect.Atomic.mk_selector_vprop_hp",
"FStar.Ghost.reveal",
"Steel.Memory.id_elim_exists",
"Steel.Effect.Atomic.hp_of_pointwise",
"Steel.Effect.Common.selector'"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p)
let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m)
let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m)
let witness_exists #a #u #p _ =
SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x)))
let lift_exists #a #u p =
as_atomic_action_ghost (Steel.Memory.lift_h_exists #u (fun x -> hp_of (p x)))
let exists_equiv p q =
Classical.forall_intro_2 reveal_equiv;
h_exists_cong (h_exists_sl' p) (h_exists_sl' q)
let exists_cong p q =
rewrite_slprop (h_exists p) (h_exists q)
(fun m ->
reveal_equiv (h_exists p) (h_exists q);
exists_equiv p q)
let fresh_invariant #uses p ctxt =
rewrite_slprop p (to_vprop (hp_of p)) (fun _ -> ());
let i = as_atomic_unobservable_action (fresh_invariant uses (hp_of p) ctxt) in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ());
return i
let new_invariant #uses p = let i = fresh_invariant #uses p [] in return i
(*
* AR: SteelAtomic and SteelGhost are not marked reifiable since we intend to run Steel programs natively
* However to implement the with_inv combinators we need to reify their thunks to reprs
* We could implement it better by having support for reification only in the .fst file
* But for now assuming a function
*)
assume val reify_steel_atomic_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames) (#g:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelAtomicBase a framed opened_invariants g pre post req ens)
: repr a framed opened_invariants g pre post req ens
[@@warn_on_use "as_unobservable_atomic_action is a trusted primitive"]
let as_atomic_o_action
(#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(o:observability)
(f:action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x))
= SteelAtomicBaseT?.reflect f
let with_invariant #a #fp #fp' #obs #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x = as_atomic_o_action obs
(Steel.Memory.with_invariant
#a
#(hp_of fp)
#(fun x -> hp_of (fp' x))
#opened
#(hp_of p)
i
(reify_steel_atomic_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return x
assume val reify_steel_ghost_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelGhostBase a framed opened_invariants Unobservable pre post req ens)
: repr a framed opened_invariants Unobservable pre post req ens
let with_invariant_g #a #fp #fp' #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x =
as_atomic_unobservable_action
(Steel.Memory.with_invariant #a #(hp_of fp) #(fun x -> hp_of (fp' x)) #opened #(hp_of p) i (reify_steel_ghost_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return (hide x)
let intro_vrefine v p =
let m = get () in
let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased (vrefine_t v p) = Ghost.hide (Ghost.reveal x) in
change_slprop
v
(vrefine v p)
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let elim_vrefine v p =
let h = get() in
let x : Ghost.erased (vrefine_t v p) = gget (vrefine v p) in
let x' : Ghost.erased (t_of v) = Ghost.hide (Ghost.reveal x) in
change_slprop
(vrefine v p)
v
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let vdep_cond
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
: Tot prop
= q == p (fst x1)
let vdep_rel
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
(x2: (t_of (vdep v p)))
: Tot prop
=
q == p (fst x1) /\
dfst (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == fst x1 /\
dsnd (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == snd x1
let intro_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (v `star` q)) m /\
q == p (fst (sel_of (v `star` q) m))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
))
=
Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m
let intro_vdep
v q p
=
reveal_star v q;
change_slprop_rel_with_cond
(v `star` q)
(vdep v p)
(vdep_cond v q p)
(vdep_rel v q p)
(fun m -> intro_vdep_lemma v q p m)
let vdep_cond_recip
(v: vprop)
(p: (t_of v -> Tot vprop))
(q: vprop)
(x2: t_of (vdep v p))
: Tot prop
= q == p (dfst (x2 <: dtuple2 (t_of v) (vdep_payload v p)))
let vdep_rel_recip
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x2: (t_of (vdep v p)))
(x1: t_of (v `star` q))
: Tot prop
=
vdep_rel v q p x1 x2
let elim_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (vdep v p)) m /\
q == p (dfst (sel_of (vdep v p) m <: dtuple2 (t_of v) (vdep_payload v p)))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
))
=
Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m
let elim_vdep0
(#opened:inames)
(v: vprop)
(p: (t_of v -> Tot vprop))
(q: vprop)
: SteelGhost unit opened
(vdep v p)
(fun _ -> v `star` q)
(requires (fun h -> q == p (dfst (h (vdep v p)))))
(ensures (fun h _ h' ->
let fs = h' v in
let sn = h' q in
let x2 = h (vdep v p) in
q == p fs /\
dfst x2 == fs /\
dsnd x2 == sn
))
= change_slprop_rel_with_cond
(vdep v p)
(v `star` q)
(vdep_cond_recip v p q)
(vdep_rel_recip v q p)
(fun m -> elim_vdep_lemma v q p m);
reveal_star v q
let elim_vdep
v p
= let r = gget (vdep v p) in
let res = Ghost.hide (dfst #(t_of v) #(vdep_payload v p) (Ghost.reveal r)) in
elim_vdep0 v p (p (Ghost.reveal res));
res
let intro_vrewrite
v #t f
= let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased t = Ghost.hide (f (Ghost.reveal x)) in
change_slprop
v
(vrewrite v f)
x
x'
(fun m ->
vrewrite_sel_eq v f m
)
let elim_vrewrite
v #t f
=
change_slprop_rel
(vrewrite v f)
v
(fun y x -> y == f x)
(fun m -> vrewrite_sel_eq v f m)
/// Deriving a selector-style vprop from an injective pts-to-style vprop
let hp_of_pointwise
(#t: Type)
(p: t -> vprop)
(x: t)
: Tot slprop
= hp_of (p x)
let mk_selector_vprop_hp
p
= Steel.Memory.h_exists (hp_of_pointwise p)
let mk_selector_vprop_sel'
(#t: Type)
(p: t -> vprop)
(p_inj: interp_hp_of_injective p) // unused in the definition, but necessary for the local SMTPats below | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mk_selector_vprop_sel' (#t: Type) (p: (t -> vprop)) (p_inj: interp_hp_of_injective p)
: Tot (selector' t (mk_selector_vprop_hp p)) | [] | Steel.Effect.Atomic.mk_selector_vprop_sel' | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: (_: t -> Steel.Effect.Common.vprop) -> p_inj: Steel.Effect.Atomic.interp_hp_of_injective p
-> Steel.Effect.Common.selector' t (Steel.Effect.Atomic.mk_selector_vprop_hp p) | {
"end_col": 47,
"end_line": 882,
"start_col": 2,
"start_line": 882
} |
Steel.Effect.Atomic.SteelGhost | val change_equal_slprop (#opened:inames) (p q: vprop)
: SteelGhost unit opened p (fun _ -> q) (fun _ -> p == q) (fun h0 _ h1 -> p == q /\ h1 q == h0 p) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ()) | val change_equal_slprop (#opened:inames) (p q: vprop)
: SteelGhost unit opened p (fun _ -> q) (fun _ -> p == q) (fun h0 _ h1 -> p == q /\ h1 q == h0 p)
let change_equal_slprop p q = | true | null | false | let m = get () in
let x:Ghost.erased (t_of p) = hide ((reveal m) p) in
let y:Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop p q x y (fun _ -> ()) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.change_slprop",
"Steel.Memory.mem",
"Prims.unit",
"FStar.Ghost.erased",
"Steel.Effect.Common.t_of",
"FStar.Ghost.hide",
"FStar.Ghost.reveal",
"Steel.Effect.Common.rmem",
"Steel.Effect.Common.rmem'",
"Steel.Effect.Common.valid_rmem",
"Steel.Effect.Atomic.get"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val change_equal_slprop (#opened:inames) (p q: vprop)
: SteelGhost unit opened p (fun _ -> q) (fun _ -> p == q) (fun h0 _ h1 -> p == q /\ h1 q == h0 p) | [] | Steel.Effect.Atomic.change_equal_slprop | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: Steel.Effect.Common.vprop -> q: Steel.Effect.Common.vprop
-> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 17,
"end_line": 438,
"start_col": 1,
"start_line": 430
} |
Steel.Effect.Atomic.SteelGhost | val intro_pure (#opened_invariants:_) (p:prop)
: SteelGhost unit opened_invariants emp (fun _ -> pure p)
(requires fun _ -> p) (ensures fun _ _ _ -> True) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m) | val intro_pure (#opened_invariants:_) (p:prop)
: SteelGhost unit opened_invariants emp (fun _ -> pure p)
(requires fun _ -> p) (ensures fun _ _ _ -> True)
let intro_pure p = | true | null | false | rewrite_slprop emp (pure p) (fun m -> pure_interp p m) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Prims.prop",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.Effect.Common.emp",
"Steel.Effect.Common.pure",
"Steel.Memory.mem",
"Steel.Memory.pure_interp",
"Prims.unit"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val intro_pure (#opened_invariants:_) (p:prop)
: SteelGhost unit opened_invariants emp (fun _ -> pure p)
(requires fun _ -> p) (ensures fun _ _ _ -> True) | [] | Steel.Effect.Atomic.intro_pure | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: Prims.prop -> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 73,
"end_line": 598,
"start_col": 19,
"start_line": 598
} |
Prims.Tot | val reveal_star_30 (#opened: inames) (p1 p2 p3: vprop)
: repr unit
false
opened
Unobservable
((p1 `star` p2) `star` p3)
(fun _ -> (p1 `star` p2) `star` p3)
(requires fun _ -> True)
(ensures
fun h0 _ h1 ->
can_be_split ((p1 `star` p2) `star` p3) p1 /\ can_be_split ((p1 `star` p2) `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 ((p1 `star` p2) `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 ((p1 `star` p2) `star` p3) == ((h1 p1, h1 p2), h1 p3)) | [
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3 | val reveal_star_30 (#opened: inames) (p1 p2 p3: vprop)
: repr unit
false
opened
Unobservable
((p1 `star` p2) `star` p3)
(fun _ -> (p1 `star` p2) `star` p3)
(requires fun _ -> True)
(ensures
fun h0 _ h1 ->
can_be_split ((p1 `star` p2) `star` p3) p1 /\ can_be_split ((p1 `star` p2) `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 ((p1 `star` p2) `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 ((p1 `star` p2) `star` p3) == ((h1 p1, h1 p2), h1 p3))
let reveal_star_30 (#opened: inames) (p1 p2 p3: vprop)
: repr unit
false
opened
Unobservable
((p1 `star` p2) `star` p3)
(fun _ -> (p1 `star` p2) `star` p3)
(requires fun _ -> True)
(ensures
fun h0 _ h1 ->
can_be_split ((p1 `star` p2) `star` p3) p1 /\ can_be_split ((p1 `star` p2) `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 ((p1 `star` p2) `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 ((p1 `star` p2) `star` p3) == ((h1 p1, h1 p2), h1 p3)) = | false | null | false | fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem ((p1 `star` p2) `star` p3) (core_mem m) in
can_be_split_trans ((p1 `star` p2) `star` p3) (p1 `star` p2) p1;
can_be_split_trans ((p1 `star` p2) `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem ((p1 `star` p2) `star` p3) m ((p1 `star` p2) `star` p3);
reveal_mk_rmem ((p1 `star` p2) `star` p3) m (p1 `star` p2);
reveal_mk_rmem ((p1 `star` p2) `star` p3) m p3 | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [
"total"
] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Memory.slprop",
"Steel.Effect.Common.reveal_mk_rmem",
"Steel.Effect.Common.star",
"Prims.unit",
"Steel.Effect.Common.can_be_split_trans",
"Steel.Effect.Common.rmem'",
"Steel.Effect.Common.valid_rmem",
"Steel.Effect.Common.mk_rmem",
"Steel.Memory.core_mem",
"FStar.Classical.forall_intro_3",
"Steel.Effect.Common.hmem",
"Steel.Effect.Common.can_be_split",
"Prims.eq2",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_of",
"Steel.Effect.Common.sel_of",
"Steel.Memory.full_mem",
"FStar.NMSTTotal.get",
"Steel.Memory.mem_evolves",
"Steel.Effect.Atomic.repr",
"Steel.Effect.Common.Unobservable",
"Steel.Effect.Common.rmem",
"Prims.l_True",
"Prims.l_and",
"FStar.Pervasives.Native.tuple2",
"Steel.Effect.Common.vprop'",
"Steel.Effect.Common.__proj__Mkvprop'__item__t",
"FStar.Pervasives.Native.Mktuple2"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val reveal_star_30 (#opened: inames) (p1 p2 p3: vprop)
: repr unit
false
opened
Unobservable
((p1 `star` p2) `star` p3)
(fun _ -> (p1 `star` p2) `star` p3)
(requires fun _ -> True)
(ensures
fun h0 _ h1 ->
can_be_split ((p1 `star` p2) `star` p3) p1 /\ can_be_split ((p1 `star` p2) `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 ((p1 `star` p2) `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 ((p1 `star` p2) `star` p3) == ((h1 p1, h1 p2), h1 p3)) | [] | Steel.Effect.Atomic.reveal_star_30 | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p1: Steel.Effect.Common.vprop -> p2: Steel.Effect.Common.vprop -> p3: Steel.Effect.Common.vprop
-> Steel.Effect.Atomic.repr Prims.unit
false
opened
Steel.Effect.Common.Unobservable
(Steel.Effect.Common.star (Steel.Effect.Common.star p1 p2) p3)
(fun _ -> Steel.Effect.Common.star (Steel.Effect.Common.star p1 p2) p3)
(fun _ -> Prims.l_True)
(fun h0 _ h1 ->
Steel.Effect.Common.can_be_split (Steel.Effect.Common.star (Steel.Effect.Common.star p1 p2
)
p3)
p1 /\
Steel.Effect.Common.can_be_split (Steel.Effect.Common.star (Steel.Effect.Common.star p1 p2
)
p3)
p2 /\ h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (Steel.Effect.Common.star (Steel.Effect.Common.star p1 p2) p3) ==
FStar.Pervasives.Native.Mktuple2 (h0 p1, h0 p2) (h0 p3) /\
h1 (Steel.Effect.Common.star (Steel.Effect.Common.star p1 p2) p3) ==
FStar.Pervasives.Native.Mktuple2 (h1 p1, h1 p2) (h1 p3)) | {
"end_col": 49,
"end_line": 594,
"start_col": 3,
"start_line": 586
} |
Steel.Effect.Atomic.SteelGhost | val reveal_star (#opened:inames) (p1 p2:vprop)
: SteelGhost unit opened (p1 `star` p2) (fun _ -> p1 `star` p2)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
h0 p1 == h1 p1 /\
h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2) | val reveal_star (#opened:inames) (p1 p2:vprop)
: SteelGhost unit opened (p1 `star` p2) (fun _ -> p1 `star` p2)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
h0 p1 == h1 p1 /\
h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
let reveal_star p1 p2 = | true | null | false | SteelGhost?.reflect (reveal_star0 p1 p2) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.reveal_star0",
"Prims.unit",
"Steel.Effect.Common.star",
"Steel.Effect.Common.rmem",
"Prims.l_True",
"Prims.l_and",
"Prims.eq2",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_of",
"FStar.Pervasives.Native.tuple2",
"Steel.Effect.Common.vprop'",
"Steel.Effect.Common.__proj__Mkvprop'__item__t",
"FStar.Pervasives.Native.Mktuple2"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val reveal_star (#opened:inames) (p1 p2:vprop)
: SteelGhost unit opened (p1 `star` p2) (fun _ -> p1 `star` p2)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
h0 p1 == h1 p1 /\
h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
) | [] | Steel.Effect.Atomic.reveal_star | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p1: Steel.Effect.Common.vprop -> p2: Steel.Effect.Common.vprop
-> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 64,
"end_line": 574,
"start_col": 24,
"start_line": 574
} |
Steel.Effect.Atomic.SteelGhostT | val intro_exists_erased (#a:Type) (#opened_invariants:_) (x:Ghost.erased a) (p:a -> vprop)
: SteelGhostT unit opened_invariants (p x) (fun _ -> h_exists p) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m) | val intro_exists_erased (#a:Type) (#opened_invariants:_) (x:Ghost.erased a) (p:a -> vprop)
: SteelGhostT unit opened_invariants (p x) (fun _ -> h_exists p)
let intro_exists_erased #a #opened x p = | true | null | false | rewrite_slprop (p x)
(h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"FStar.Ghost.erased",
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.rewrite_slprop",
"FStar.Ghost.reveal",
"Steel.Effect.Atomic.h_exists",
"Steel.Memory.mem",
"Steel.Memory.intro_h_exists",
"Steel.Effect.Atomic.h_exists_sl'",
"Prims.unit"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p)
let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val intro_exists_erased (#a:Type) (#opened_invariants:_) (x:Ghost.erased a) (p:a -> vprop)
: SteelGhostT unit opened_invariants (p x) (fun _ -> h_exists p) | [] | Steel.Effect.Atomic.intro_exists_erased | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | x: FStar.Ghost.erased a -> p: (_: a -> Steel.Effect.Common.vprop)
-> Steel.Effect.Atomic.SteelGhostT Prims.unit | {
"end_col": 78,
"end_line": 615,
"start_col": 2,
"start_line": 614
} |
Steel.Effect.Atomic.SteelGhost | val elim_vrewrite (#opened:inames)
(v: vprop)
(#t: Type)
(f: (normal (t_of v) -> GTot t))
: SteelGhost unit opened (vrewrite v f) (fun _ -> v)
(fun _ -> True)
(fun h _ h' -> h (vrewrite v f) == f (h' v)) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let elim_vrewrite
v #t f
=
change_slprop_rel
(vrewrite v f)
v
(fun y x -> y == f x)
(fun m -> vrewrite_sel_eq v f m) | val elim_vrewrite (#opened:inames)
(v: vprop)
(#t: Type)
(f: (normal (t_of v) -> GTot t))
: SteelGhost unit opened (vrewrite v f) (fun _ -> v)
(fun _ -> True)
(fun h _ h' -> h (vrewrite v f) == f (h' v))
let elim_vrewrite v #t f = | true | null | false | change_slprop_rel (vrewrite v f) v (fun y x -> y == f x) (fun m -> vrewrite_sel_eq v f m) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_of",
"Steel.Effect.Atomic.change_slprop_rel",
"Steel.Effect.Common.vrewrite",
"Prims.eq2",
"Prims.prop",
"Steel.Memory.mem",
"Steel.Effect.Common.vrewrite_sel_eq",
"Prims.unit"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p)
let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m)
let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m)
let witness_exists #a #u #p _ =
SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x)))
let lift_exists #a #u p =
as_atomic_action_ghost (Steel.Memory.lift_h_exists #u (fun x -> hp_of (p x)))
let exists_equiv p q =
Classical.forall_intro_2 reveal_equiv;
h_exists_cong (h_exists_sl' p) (h_exists_sl' q)
let exists_cong p q =
rewrite_slprop (h_exists p) (h_exists q)
(fun m ->
reveal_equiv (h_exists p) (h_exists q);
exists_equiv p q)
let fresh_invariant #uses p ctxt =
rewrite_slprop p (to_vprop (hp_of p)) (fun _ -> ());
let i = as_atomic_unobservable_action (fresh_invariant uses (hp_of p) ctxt) in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ());
return i
let new_invariant #uses p = let i = fresh_invariant #uses p [] in return i
(*
* AR: SteelAtomic and SteelGhost are not marked reifiable since we intend to run Steel programs natively
* However to implement the with_inv combinators we need to reify their thunks to reprs
* We could implement it better by having support for reification only in the .fst file
* But for now assuming a function
*)
assume val reify_steel_atomic_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames) (#g:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelAtomicBase a framed opened_invariants g pre post req ens)
: repr a framed opened_invariants g pre post req ens
[@@warn_on_use "as_unobservable_atomic_action is a trusted primitive"]
let as_atomic_o_action
(#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(o:observability)
(f:action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x))
= SteelAtomicBaseT?.reflect f
let with_invariant #a #fp #fp' #obs #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x = as_atomic_o_action obs
(Steel.Memory.with_invariant
#a
#(hp_of fp)
#(fun x -> hp_of (fp' x))
#opened
#(hp_of p)
i
(reify_steel_atomic_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return x
assume val reify_steel_ghost_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelGhostBase a framed opened_invariants Unobservable pre post req ens)
: repr a framed opened_invariants Unobservable pre post req ens
let with_invariant_g #a #fp #fp' #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x =
as_atomic_unobservable_action
(Steel.Memory.with_invariant #a #(hp_of fp) #(fun x -> hp_of (fp' x)) #opened #(hp_of p) i (reify_steel_ghost_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return (hide x)
let intro_vrefine v p =
let m = get () in
let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased (vrefine_t v p) = Ghost.hide (Ghost.reveal x) in
change_slprop
v
(vrefine v p)
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let elim_vrefine v p =
let h = get() in
let x : Ghost.erased (vrefine_t v p) = gget (vrefine v p) in
let x' : Ghost.erased (t_of v) = Ghost.hide (Ghost.reveal x) in
change_slprop
(vrefine v p)
v
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let vdep_cond
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
: Tot prop
= q == p (fst x1)
let vdep_rel
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
(x2: (t_of (vdep v p)))
: Tot prop
=
q == p (fst x1) /\
dfst (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == fst x1 /\
dsnd (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == snd x1
let intro_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (v `star` q)) m /\
q == p (fst (sel_of (v `star` q) m))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
))
=
Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m
let intro_vdep
v q p
=
reveal_star v q;
change_slprop_rel_with_cond
(v `star` q)
(vdep v p)
(vdep_cond v q p)
(vdep_rel v q p)
(fun m -> intro_vdep_lemma v q p m)
let vdep_cond_recip
(v: vprop)
(p: (t_of v -> Tot vprop))
(q: vprop)
(x2: t_of (vdep v p))
: Tot prop
= q == p (dfst (x2 <: dtuple2 (t_of v) (vdep_payload v p)))
let vdep_rel_recip
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x2: (t_of (vdep v p)))
(x1: t_of (v `star` q))
: Tot prop
=
vdep_rel v q p x1 x2
let elim_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (vdep v p)) m /\
q == p (dfst (sel_of (vdep v p) m <: dtuple2 (t_of v) (vdep_payload v p)))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
))
=
Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m
let elim_vdep0
(#opened:inames)
(v: vprop)
(p: (t_of v -> Tot vprop))
(q: vprop)
: SteelGhost unit opened
(vdep v p)
(fun _ -> v `star` q)
(requires (fun h -> q == p (dfst (h (vdep v p)))))
(ensures (fun h _ h' ->
let fs = h' v in
let sn = h' q in
let x2 = h (vdep v p) in
q == p fs /\
dfst x2 == fs /\
dsnd x2 == sn
))
= change_slprop_rel_with_cond
(vdep v p)
(v `star` q)
(vdep_cond_recip v p q)
(vdep_rel_recip v q p)
(fun m -> elim_vdep_lemma v q p m);
reveal_star v q
let elim_vdep
v p
= let r = gget (vdep v p) in
let res = Ghost.hide (dfst #(t_of v) #(vdep_payload v p) (Ghost.reveal r)) in
elim_vdep0 v p (p (Ghost.reveal res));
res
let intro_vrewrite
v #t f
= let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased t = Ghost.hide (f (Ghost.reveal x)) in
change_slprop
v
(vrewrite v f)
x
x'
(fun m ->
vrewrite_sel_eq v f m
)
let elim_vrewrite
v #t f | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val elim_vrewrite (#opened:inames)
(v: vprop)
(#t: Type)
(f: (normal (t_of v) -> GTot t))
: SteelGhost unit opened (vrewrite v f) (fun _ -> v)
(fun _ -> True)
(fun h _ h' -> h (vrewrite v f) == f (h' v)) | [] | Steel.Effect.Atomic.elim_vrewrite | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
v: Steel.Effect.Common.vprop ->
f: (_: Steel.Effect.Common.normal (Steel.Effect.Common.t_of v) -> Prims.GTot t)
-> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 36,
"end_line": 862,
"start_col": 2,
"start_line": 858
} |
Steel.Effect.Atomic.SteelGhost | val mk_selector_vprop_intro
(#opened: _) (#t: Type0) (#x: t)
(p: t -> vprop) (p_inj: interp_hp_of_injective p)
: SteelGhost unit opened
(p x)
(fun _ -> mk_selector_vprop p p_inj)
(fun _ -> True)
(fun _ _ h' -> h' (mk_selector_vprop p p_inj) == x) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mk_selector_vprop_intro
#_ #_ #x p p_inj
= change_slprop_rel
(p _)
(mk_selector_vprop p p_inj)
(fun _ x' -> x == x')
(fun m ->
intro_h_exists x (hp_of_pointwise p) m;
let x' = mk_selector_vprop_sel' p p_inj m in
p_inj x x' m
) | val mk_selector_vprop_intro
(#opened: _) (#t: Type0) (#x: t)
(p: t -> vprop) (p_inj: interp_hp_of_injective p)
: SteelGhost unit opened
(p x)
(fun _ -> mk_selector_vprop p p_inj)
(fun _ -> True)
(fun _ _ h' -> h' (mk_selector_vprop p p_inj) == x)
let mk_selector_vprop_intro #_ #_ #x p p_inj = | true | null | false | change_slprop_rel (p _)
(mk_selector_vprop p p_inj)
(fun _ x' -> x == x')
(fun m ->
intro_h_exists x (hp_of_pointwise p) m;
let x' = mk_selector_vprop_sel' p p_inj m in
p_inj x x' m) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.interp_hp_of_injective",
"Steel.Effect.Atomic.change_slprop_rel",
"Steel.Effect.Atomic.mk_selector_vprop",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_of",
"Prims.eq2",
"Prims.prop",
"Steel.Memory.mem",
"Steel.Effect.Atomic.mk_selector_vprop_sel'",
"Prims.unit",
"Steel.Memory.intro_h_exists",
"Steel.Effect.Atomic.hp_of_pointwise"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p)
let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m)
let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m)
let witness_exists #a #u #p _ =
SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x)))
let lift_exists #a #u p =
as_atomic_action_ghost (Steel.Memory.lift_h_exists #u (fun x -> hp_of (p x)))
let exists_equiv p q =
Classical.forall_intro_2 reveal_equiv;
h_exists_cong (h_exists_sl' p) (h_exists_sl' q)
let exists_cong p q =
rewrite_slprop (h_exists p) (h_exists q)
(fun m ->
reveal_equiv (h_exists p) (h_exists q);
exists_equiv p q)
let fresh_invariant #uses p ctxt =
rewrite_slprop p (to_vprop (hp_of p)) (fun _ -> ());
let i = as_atomic_unobservable_action (fresh_invariant uses (hp_of p) ctxt) in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ());
return i
let new_invariant #uses p = let i = fresh_invariant #uses p [] in return i
(*
* AR: SteelAtomic and SteelGhost are not marked reifiable since we intend to run Steel programs natively
* However to implement the with_inv combinators we need to reify their thunks to reprs
* We could implement it better by having support for reification only in the .fst file
* But for now assuming a function
*)
assume val reify_steel_atomic_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames) (#g:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelAtomicBase a framed opened_invariants g pre post req ens)
: repr a framed opened_invariants g pre post req ens
[@@warn_on_use "as_unobservable_atomic_action is a trusted primitive"]
let as_atomic_o_action
(#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(o:observability)
(f:action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x))
= SteelAtomicBaseT?.reflect f
let with_invariant #a #fp #fp' #obs #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x = as_atomic_o_action obs
(Steel.Memory.with_invariant
#a
#(hp_of fp)
#(fun x -> hp_of (fp' x))
#opened
#(hp_of p)
i
(reify_steel_atomic_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return x
assume val reify_steel_ghost_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelGhostBase a framed opened_invariants Unobservable pre post req ens)
: repr a framed opened_invariants Unobservable pre post req ens
let with_invariant_g #a #fp #fp' #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x =
as_atomic_unobservable_action
(Steel.Memory.with_invariant #a #(hp_of fp) #(fun x -> hp_of (fp' x)) #opened #(hp_of p) i (reify_steel_ghost_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return (hide x)
let intro_vrefine v p =
let m = get () in
let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased (vrefine_t v p) = Ghost.hide (Ghost.reveal x) in
change_slprop
v
(vrefine v p)
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let elim_vrefine v p =
let h = get() in
let x : Ghost.erased (vrefine_t v p) = gget (vrefine v p) in
let x' : Ghost.erased (t_of v) = Ghost.hide (Ghost.reveal x) in
change_slprop
(vrefine v p)
v
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let vdep_cond
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
: Tot prop
= q == p (fst x1)
let vdep_rel
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
(x2: (t_of (vdep v p)))
: Tot prop
=
q == p (fst x1) /\
dfst (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == fst x1 /\
dsnd (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == snd x1
let intro_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (v `star` q)) m /\
q == p (fst (sel_of (v `star` q) m))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
))
=
Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m
let intro_vdep
v q p
=
reveal_star v q;
change_slprop_rel_with_cond
(v `star` q)
(vdep v p)
(vdep_cond v q p)
(vdep_rel v q p)
(fun m -> intro_vdep_lemma v q p m)
let vdep_cond_recip
(v: vprop)
(p: (t_of v -> Tot vprop))
(q: vprop)
(x2: t_of (vdep v p))
: Tot prop
= q == p (dfst (x2 <: dtuple2 (t_of v) (vdep_payload v p)))
let vdep_rel_recip
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x2: (t_of (vdep v p)))
(x1: t_of (v `star` q))
: Tot prop
=
vdep_rel v q p x1 x2
let elim_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (vdep v p)) m /\
q == p (dfst (sel_of (vdep v p) m <: dtuple2 (t_of v) (vdep_payload v p)))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
))
=
Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m
let elim_vdep0
(#opened:inames)
(v: vprop)
(p: (t_of v -> Tot vprop))
(q: vprop)
: SteelGhost unit opened
(vdep v p)
(fun _ -> v `star` q)
(requires (fun h -> q == p (dfst (h (vdep v p)))))
(ensures (fun h _ h' ->
let fs = h' v in
let sn = h' q in
let x2 = h (vdep v p) in
q == p fs /\
dfst x2 == fs /\
dsnd x2 == sn
))
= change_slprop_rel_with_cond
(vdep v p)
(v `star` q)
(vdep_cond_recip v p q)
(vdep_rel_recip v q p)
(fun m -> elim_vdep_lemma v q p m);
reveal_star v q
let elim_vdep
v p
= let r = gget (vdep v p) in
let res = Ghost.hide (dfst #(t_of v) #(vdep_payload v p) (Ghost.reveal r)) in
elim_vdep0 v p (p (Ghost.reveal res));
res
let intro_vrewrite
v #t f
= let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased t = Ghost.hide (f (Ghost.reveal x)) in
change_slprop
v
(vrewrite v f)
x
x'
(fun m ->
vrewrite_sel_eq v f m
)
let elim_vrewrite
v #t f
=
change_slprop_rel
(vrewrite v f)
v
(fun y x -> y == f x)
(fun m -> vrewrite_sel_eq v f m)
/// Deriving a selector-style vprop from an injective pts-to-style vprop
let hp_of_pointwise
(#t: Type)
(p: t -> vprop)
(x: t)
: Tot slprop
= hp_of (p x)
let mk_selector_vprop_hp
p
= Steel.Memory.h_exists (hp_of_pointwise p)
let mk_selector_vprop_sel'
(#t: Type)
(p: t -> vprop)
(p_inj: interp_hp_of_injective p) // unused in the definition, but necessary for the local SMTPats below
: Tot (selector' t (mk_selector_vprop_hp p))
= fun m -> id_elim_exists (hp_of_pointwise p) m
let mk_selector_vprop_sel
#t p p_inj
=
let varrayp_sel_depends_only_on
(#t: Type)
(p: t -> vprop)
(p_inj: interp_hp_of_injective p)
(m0: Steel.Memory.hmem (mk_selector_vprop_hp p))
(m1: mem { disjoint m0 m1 })
: Lemma
(
mk_selector_vprop_sel' p p_inj m0 == mk_selector_vprop_sel' p p_inj (Steel.Memory.join m0 m1)
)
[SMTPat (mk_selector_vprop_sel' p p_inj (Steel.Memory.join m0 m1))]
= p_inj (mk_selector_vprop_sel' p p_inj m0) (mk_selector_vprop_sel' p p_inj (Steel.Memory.join m0 m1)) (Steel.Memory.join m0 m1)
in
let varrayp_sel_depends_only_on_core
(#t: Type)
(p: t -> vprop)
(p_inj: interp_hp_of_injective p)
(m0: Steel.Memory.hmem (mk_selector_vprop_hp p))
: Lemma
(
mk_selector_vprop_sel' p p_inj m0 == mk_selector_vprop_sel' p p_inj (core_mem m0)
)
[SMTPat (mk_selector_vprop_sel' p p_inj (core_mem m0))]
= p_inj (mk_selector_vprop_sel' p p_inj m0) (mk_selector_vprop_sel' p p_inj (core_mem m0)) m0
in
mk_selector_vprop_sel' p p_inj
let mk_selector_vprop_intro | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mk_selector_vprop_intro
(#opened: _) (#t: Type0) (#x: t)
(p: t -> vprop) (p_inj: interp_hp_of_injective p)
: SteelGhost unit opened
(p x)
(fun _ -> mk_selector_vprop p p_inj)
(fun _ -> True)
(fun _ _ h' -> h' (mk_selector_vprop p p_inj) == x) | [] | Steel.Effect.Atomic.mk_selector_vprop_intro | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: (_: t -> Steel.Effect.Common.vprop) -> p_inj: Steel.Effect.Atomic.interp_hp_of_injective p
-> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 5,
"end_line": 924,
"start_col": 2,
"start_line": 916
} |
Steel.Effect.Atomic.SteelGhost | val elim_pure (#uses:_) (p:prop)
: SteelGhost unit uses (pure p) (fun _ -> emp)
(requires fun _ -> True) (ensures fun _ _ _ -> p) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ()) | val elim_pure (#uses:_) (p:prop)
: SteelGhost unit uses (pure p) (fun _ -> emp)
(requires fun _ -> True) (ensures fun _ _ _ -> p)
let elim_pure #uses p = | true | null | false | let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ()) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Prims.prop",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.Effect.Common.to_vprop",
"Steel.Memory.emp",
"Steel.Effect.Common.emp",
"Steel.Memory.mem",
"Steel.Effect.Common.reveal_emp",
"Prims.unit",
"Steel.Effect.Atomic.elim_pure_aux"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val elim_pure (#uses:_) (p:prop)
: SteelGhost unit uses (pure p) (fun _ -> emp)
(requires fun _ -> True) (ensures fun _ _ _ -> p) | [] | Steel.Effect.Atomic.elim_pure | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: Prims.prop -> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 64,
"end_line": 606,
"start_col": 23,
"start_line": 604
} |
Steel.Effect.Atomic.SteelGhost | val elim_vdep0 (#opened: inames) (v: vprop) (p: (t_of v -> Tot vprop)) (q: vprop)
: SteelGhost unit
opened
(vdep v p)
(fun _ -> v `star` q)
(requires (fun h -> q == p (dfst (h (vdep v p)))))
(ensures
(fun h _ h' ->
let fs = h' v in
let sn = h' q in
let x2 = h (vdep v p) in
q == p fs /\ dfst x2 == fs /\ dsnd x2 == sn)) | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let elim_vdep0
(#opened:inames)
(v: vprop)
(p: (t_of v -> Tot vprop))
(q: vprop)
: SteelGhost unit opened
(vdep v p)
(fun _ -> v `star` q)
(requires (fun h -> q == p (dfst (h (vdep v p)))))
(ensures (fun h _ h' ->
let fs = h' v in
let sn = h' q in
let x2 = h (vdep v p) in
q == p fs /\
dfst x2 == fs /\
dsnd x2 == sn
))
= change_slprop_rel_with_cond
(vdep v p)
(v `star` q)
(vdep_cond_recip v p q)
(vdep_rel_recip v q p)
(fun m -> elim_vdep_lemma v q p m);
reveal_star v q | val elim_vdep0 (#opened: inames) (v: vprop) (p: (t_of v -> Tot vprop)) (q: vprop)
: SteelGhost unit
opened
(vdep v p)
(fun _ -> v `star` q)
(requires (fun h -> q == p (dfst (h (vdep v p)))))
(ensures
(fun h _ h' ->
let fs = h' v in
let sn = h' q in
let x2 = h (vdep v p) in
q == p fs /\ dfst x2 == fs /\ dsnd x2 == sn))
let elim_vdep0 (#opened: inames) (v: vprop) (p: (t_of v -> Tot vprop)) (q: vprop)
: SteelGhost unit
opened
(vdep v p)
(fun _ -> v `star` q)
(requires (fun h -> q == p (dfst (h (vdep v p)))))
(ensures
(fun h _ h' ->
let fs = h' v in
let sn = h' q in
let x2 = h (vdep v p) in
q == p fs /\ dfst x2 == fs /\ dsnd x2 == sn)) = | true | null | false | change_slprop_rel_with_cond (vdep v p)
(v `star` q)
(vdep_cond_recip v p q)
(vdep_rel_recip v q p)
(fun m -> elim_vdep_lemma v q p m);
reveal_star v q | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.t_of",
"Steel.Effect.Atomic.reveal_star",
"Prims.unit",
"Steel.Effect.Atomic.change_slprop_rel_with_cond",
"Steel.Effect.Common.vdep",
"Steel.Effect.Common.star",
"Steel.Effect.Atomic.vdep_cond_recip",
"Steel.Effect.Atomic.vdep_rel_recip",
"Steel.Memory.mem",
"Steel.Effect.Atomic.elim_vdep_lemma",
"Steel.Effect.Common.rmem",
"Prims.eq2",
"FStar.Pervasives.dfst",
"Steel.Effect.Common.vdep_payload",
"Prims.l_and",
"Steel.Effect.Common.normal",
"FStar.Pervasives.dsnd",
"FStar.Pervasives.norm",
"Prims.Cons",
"FStar.Pervasives.norm_step",
"FStar.Pervasives.delta_attr",
"Prims.string",
"Prims.Nil",
"FStar.Pervasives.delta_only",
"FStar.Pervasives.delta_qualifier",
"FStar.Pervasives.iota",
"FStar.Pervasives.zeta",
"FStar.Pervasives.primops",
"FStar.Pervasives.simplify"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p)
let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m)
let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m)
let witness_exists #a #u #p _ =
SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x)))
let lift_exists #a #u p =
as_atomic_action_ghost (Steel.Memory.lift_h_exists #u (fun x -> hp_of (p x)))
let exists_equiv p q =
Classical.forall_intro_2 reveal_equiv;
h_exists_cong (h_exists_sl' p) (h_exists_sl' q)
let exists_cong p q =
rewrite_slprop (h_exists p) (h_exists q)
(fun m ->
reveal_equiv (h_exists p) (h_exists q);
exists_equiv p q)
let fresh_invariant #uses p ctxt =
rewrite_slprop p (to_vprop (hp_of p)) (fun _ -> ());
let i = as_atomic_unobservable_action (fresh_invariant uses (hp_of p) ctxt) in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ());
return i
let new_invariant #uses p = let i = fresh_invariant #uses p [] in return i
(*
* AR: SteelAtomic and SteelGhost are not marked reifiable since we intend to run Steel programs natively
* However to implement the with_inv combinators we need to reify their thunks to reprs
* We could implement it better by having support for reification only in the .fst file
* But for now assuming a function
*)
assume val reify_steel_atomic_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames) (#g:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelAtomicBase a framed opened_invariants g pre post req ens)
: repr a framed opened_invariants g pre post req ens
[@@warn_on_use "as_unobservable_atomic_action is a trusted primitive"]
let as_atomic_o_action
(#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(o:observability)
(f:action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x))
= SteelAtomicBaseT?.reflect f
let with_invariant #a #fp #fp' #obs #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x = as_atomic_o_action obs
(Steel.Memory.with_invariant
#a
#(hp_of fp)
#(fun x -> hp_of (fp' x))
#opened
#(hp_of p)
i
(reify_steel_atomic_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return x
assume val reify_steel_ghost_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelGhostBase a framed opened_invariants Unobservable pre post req ens)
: repr a framed opened_invariants Unobservable pre post req ens
let with_invariant_g #a #fp #fp' #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x =
as_atomic_unobservable_action
(Steel.Memory.with_invariant #a #(hp_of fp) #(fun x -> hp_of (fp' x)) #opened #(hp_of p) i (reify_steel_ghost_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return (hide x)
let intro_vrefine v p =
let m = get () in
let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased (vrefine_t v p) = Ghost.hide (Ghost.reveal x) in
change_slprop
v
(vrefine v p)
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let elim_vrefine v p =
let h = get() in
let x : Ghost.erased (vrefine_t v p) = gget (vrefine v p) in
let x' : Ghost.erased (t_of v) = Ghost.hide (Ghost.reveal x) in
change_slprop
(vrefine v p)
v
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let vdep_cond
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
: Tot prop
= q == p (fst x1)
let vdep_rel
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
(x2: (t_of (vdep v p)))
: Tot prop
=
q == p (fst x1) /\
dfst (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == fst x1 /\
dsnd (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == snd x1
let intro_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (v `star` q)) m /\
q == p (fst (sel_of (v `star` q) m))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
))
=
Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m
let intro_vdep
v q p
=
reveal_star v q;
change_slprop_rel_with_cond
(v `star` q)
(vdep v p)
(vdep_cond v q p)
(vdep_rel v q p)
(fun m -> intro_vdep_lemma v q p m)
let vdep_cond_recip
(v: vprop)
(p: (t_of v -> Tot vprop))
(q: vprop)
(x2: t_of (vdep v p))
: Tot prop
= q == p (dfst (x2 <: dtuple2 (t_of v) (vdep_payload v p)))
let vdep_rel_recip
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x2: (t_of (vdep v p)))
(x1: t_of (v `star` q))
: Tot prop
=
vdep_rel v q p x1 x2
let elim_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (vdep v p)) m /\
q == p (dfst (sel_of (vdep v p) m <: dtuple2 (t_of v) (vdep_payload v p)))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
))
=
Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m
let elim_vdep0
(#opened:inames)
(v: vprop)
(p: (t_of v -> Tot vprop))
(q: vprop)
: SteelGhost unit opened
(vdep v p)
(fun _ -> v `star` q)
(requires (fun h -> q == p (dfst (h (vdep v p)))))
(ensures (fun h _ h' ->
let fs = h' v in
let sn = h' q in
let x2 = h (vdep v p) in
q == p fs /\
dfst x2 == fs /\
dsnd x2 == sn | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val elim_vdep0 (#opened: inames) (v: vprop) (p: (t_of v -> Tot vprop)) (q: vprop)
: SteelGhost unit
opened
(vdep v p)
(fun _ -> v `star` q)
(requires (fun h -> q == p (dfst (h (vdep v p)))))
(ensures
(fun h _ h' ->
let fs = h' v in
let sn = h' q in
let x2 = h (vdep v p) in
q == p fs /\ dfst x2 == fs /\ dsnd x2 == sn)) | [] | Steel.Effect.Atomic.elim_vdep0 | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
v: Steel.Effect.Common.vprop ->
p: (_: Steel.Effect.Common.t_of v -> Steel.Effect.Common.vprop) ->
q: Steel.Effect.Common.vprop
-> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 17,
"end_line": 833,
"start_col": 2,
"start_line": 827
} |
Steel.Effect.Atomic.SteelGhost | val elim_vrefine (#opened:inames)
(v: vprop) (p: (normal (t_of v) -> Tot prop))
: SteelGhost unit opened (vrefine v p) (fun _ -> v)
(requires fun _ -> True)
(ensures fun h _ h' -> h' v == h (vrefine v p) /\ p (h' v)) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let elim_vrefine v p =
let h = get() in
let x : Ghost.erased (vrefine_t v p) = gget (vrefine v p) in
let x' : Ghost.erased (t_of v) = Ghost.hide (Ghost.reveal x) in
change_slprop
(vrefine v p)
v
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
) | val elim_vrefine (#opened:inames)
(v: vprop) (p: (normal (t_of v) -> Tot prop))
: SteelGhost unit opened (vrefine v p) (fun _ -> v)
(requires fun _ -> True)
(ensures fun h _ h' -> h' v == h (vrefine v p) /\ p (h' v))
let elim_vrefine v p = | true | null | false | let h = get () in
let x:Ghost.erased (vrefine_t v p) = gget (vrefine v p) in
let x':Ghost.erased (t_of v) = Ghost.hide (Ghost.reveal x) in
change_slprop (vrefine v p)
v
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_of",
"Prims.prop",
"Steel.Effect.Atomic.change_slprop",
"Steel.Effect.Common.vrefine",
"Steel.Memory.mem",
"Steel.Effect.Common.vrefine_sel_eq",
"Prims.unit",
"Steel.Effect.Common.interp_vrefine_hp",
"FStar.Ghost.erased",
"FStar.Ghost.hide",
"FStar.Ghost.reveal",
"Steel.Effect.Common.vrefine_t",
"Steel.Effect.Atomic.gget",
"Steel.Effect.Common.rmem'",
"Steel.Effect.Common.valid_rmem",
"Steel.Effect.Atomic.get",
"Steel.Effect.Common.rmem"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p)
let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m)
let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m)
let witness_exists #a #u #p _ =
SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x)))
let lift_exists #a #u p =
as_atomic_action_ghost (Steel.Memory.lift_h_exists #u (fun x -> hp_of (p x)))
let exists_equiv p q =
Classical.forall_intro_2 reveal_equiv;
h_exists_cong (h_exists_sl' p) (h_exists_sl' q)
let exists_cong p q =
rewrite_slprop (h_exists p) (h_exists q)
(fun m ->
reveal_equiv (h_exists p) (h_exists q);
exists_equiv p q)
let fresh_invariant #uses p ctxt =
rewrite_slprop p (to_vprop (hp_of p)) (fun _ -> ());
let i = as_atomic_unobservable_action (fresh_invariant uses (hp_of p) ctxt) in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ());
return i
let new_invariant #uses p = let i = fresh_invariant #uses p [] in return i
(*
* AR: SteelAtomic and SteelGhost are not marked reifiable since we intend to run Steel programs natively
* However to implement the with_inv combinators we need to reify their thunks to reprs
* We could implement it better by having support for reification only in the .fst file
* But for now assuming a function
*)
assume val reify_steel_atomic_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames) (#g:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelAtomicBase a framed opened_invariants g pre post req ens)
: repr a framed opened_invariants g pre post req ens
[@@warn_on_use "as_unobservable_atomic_action is a trusted primitive"]
let as_atomic_o_action
(#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(o:observability)
(f:action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x))
= SteelAtomicBaseT?.reflect f
let with_invariant #a #fp #fp' #obs #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x = as_atomic_o_action obs
(Steel.Memory.with_invariant
#a
#(hp_of fp)
#(fun x -> hp_of (fp' x))
#opened
#(hp_of p)
i
(reify_steel_atomic_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return x
assume val reify_steel_ghost_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelGhostBase a framed opened_invariants Unobservable pre post req ens)
: repr a framed opened_invariants Unobservable pre post req ens
let with_invariant_g #a #fp #fp' #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x =
as_atomic_unobservable_action
(Steel.Memory.with_invariant #a #(hp_of fp) #(fun x -> hp_of (fp' x)) #opened #(hp_of p) i (reify_steel_ghost_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return (hide x)
let intro_vrefine v p =
let m = get () in
let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased (vrefine_t v p) = Ghost.hide (Ghost.reveal x) in
change_slprop
v
(vrefine v p)
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val elim_vrefine (#opened:inames)
(v: vprop) (p: (normal (t_of v) -> Tot prop))
: SteelGhost unit opened (vrefine v p) (fun _ -> v)
(requires fun _ -> True)
(ensures fun h _ h' -> h' v == h (vrefine v p) /\ p (h' v)) | [] | Steel.Effect.Atomic.elim_vrefine | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
v: Steel.Effect.Common.vprop ->
p: (_: Steel.Effect.Common.normal (Steel.Effect.Common.t_of v) -> Prims.prop)
-> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 5,
"end_line": 719,
"start_col": 22,
"start_line": 707
} |
Steel.Effect.Atomic.SteelGhost | val elim_vdep (#opened:inames)
(v: vprop)
(p: (t_of v -> Tot vprop))
: SteelGhost (Ghost.erased (t_of v)) opened
(vdep v p)
(fun res -> v `star` p (Ghost.reveal res))
(requires (fun _ -> True))
(ensures (fun h res h' ->
let fs = h' v in
let sn : t_of (p (Ghost.reveal res)) = h' (p (Ghost.reveal res)) in
let x2 = h (vdep v p) in
Ghost.reveal res == fs /\
dfst x2 == fs /\
dsnd x2 == sn
)) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let elim_vdep
v p
= let r = gget (vdep v p) in
let res = Ghost.hide (dfst #(t_of v) #(vdep_payload v p) (Ghost.reveal r)) in
elim_vdep0 v p (p (Ghost.reveal res));
res | val elim_vdep (#opened:inames)
(v: vprop)
(p: (t_of v -> Tot vprop))
: SteelGhost (Ghost.erased (t_of v)) opened
(vdep v p)
(fun res -> v `star` p (Ghost.reveal res))
(requires (fun _ -> True))
(ensures (fun h res h' ->
let fs = h' v in
let sn : t_of (p (Ghost.reveal res)) = h' (p (Ghost.reveal res)) in
let x2 = h (vdep v p) in
Ghost.reveal res == fs /\
dfst x2 == fs /\
dsnd x2 == sn
))
let elim_vdep v p = | true | null | false | let r = gget (vdep v p) in
let res = Ghost.hide (dfst #(t_of v) #(vdep_payload v p) (Ghost.reveal r)) in
elim_vdep0 v p (p (Ghost.reveal res));
res | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.t_of",
"FStar.Ghost.erased",
"Prims.unit",
"Steel.Effect.Atomic.elim_vdep0",
"FStar.Ghost.reveal",
"FStar.Ghost.hide",
"FStar.Pervasives.dfst",
"Steel.Effect.Common.vdep_payload",
"Steel.Effect.Common.vdep",
"Steel.Effect.Atomic.gget"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p)
let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m)
let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m)
let witness_exists #a #u #p _ =
SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x)))
let lift_exists #a #u p =
as_atomic_action_ghost (Steel.Memory.lift_h_exists #u (fun x -> hp_of (p x)))
let exists_equiv p q =
Classical.forall_intro_2 reveal_equiv;
h_exists_cong (h_exists_sl' p) (h_exists_sl' q)
let exists_cong p q =
rewrite_slprop (h_exists p) (h_exists q)
(fun m ->
reveal_equiv (h_exists p) (h_exists q);
exists_equiv p q)
let fresh_invariant #uses p ctxt =
rewrite_slprop p (to_vprop (hp_of p)) (fun _ -> ());
let i = as_atomic_unobservable_action (fresh_invariant uses (hp_of p) ctxt) in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ());
return i
let new_invariant #uses p = let i = fresh_invariant #uses p [] in return i
(*
* AR: SteelAtomic and SteelGhost are not marked reifiable since we intend to run Steel programs natively
* However to implement the with_inv combinators we need to reify their thunks to reprs
* We could implement it better by having support for reification only in the .fst file
* But for now assuming a function
*)
assume val reify_steel_atomic_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames) (#g:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelAtomicBase a framed opened_invariants g pre post req ens)
: repr a framed opened_invariants g pre post req ens
[@@warn_on_use "as_unobservable_atomic_action is a trusted primitive"]
let as_atomic_o_action
(#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(o:observability)
(f:action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x))
= SteelAtomicBaseT?.reflect f
let with_invariant #a #fp #fp' #obs #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x = as_atomic_o_action obs
(Steel.Memory.with_invariant
#a
#(hp_of fp)
#(fun x -> hp_of (fp' x))
#opened
#(hp_of p)
i
(reify_steel_atomic_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return x
assume val reify_steel_ghost_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelGhostBase a framed opened_invariants Unobservable pre post req ens)
: repr a framed opened_invariants Unobservable pre post req ens
let with_invariant_g #a #fp #fp' #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x =
as_atomic_unobservable_action
(Steel.Memory.with_invariant #a #(hp_of fp) #(fun x -> hp_of (fp' x)) #opened #(hp_of p) i (reify_steel_ghost_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return (hide x)
let intro_vrefine v p =
let m = get () in
let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased (vrefine_t v p) = Ghost.hide (Ghost.reveal x) in
change_slprop
v
(vrefine v p)
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let elim_vrefine v p =
let h = get() in
let x : Ghost.erased (vrefine_t v p) = gget (vrefine v p) in
let x' : Ghost.erased (t_of v) = Ghost.hide (Ghost.reveal x) in
change_slprop
(vrefine v p)
v
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let vdep_cond
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
: Tot prop
= q == p (fst x1)
let vdep_rel
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
(x2: (t_of (vdep v p)))
: Tot prop
=
q == p (fst x1) /\
dfst (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == fst x1 /\
dsnd (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == snd x1
let intro_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (v `star` q)) m /\
q == p (fst (sel_of (v `star` q) m))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
))
=
Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m
let intro_vdep
v q p
=
reveal_star v q;
change_slprop_rel_with_cond
(v `star` q)
(vdep v p)
(vdep_cond v q p)
(vdep_rel v q p)
(fun m -> intro_vdep_lemma v q p m)
let vdep_cond_recip
(v: vprop)
(p: (t_of v -> Tot vprop))
(q: vprop)
(x2: t_of (vdep v p))
: Tot prop
= q == p (dfst (x2 <: dtuple2 (t_of v) (vdep_payload v p)))
let vdep_rel_recip
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x2: (t_of (vdep v p)))
(x1: t_of (v `star` q))
: Tot prop
=
vdep_rel v q p x1 x2
let elim_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (vdep v p)) m /\
q == p (dfst (sel_of (vdep v p) m <: dtuple2 (t_of v) (vdep_payload v p)))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
))
=
Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m
let elim_vdep0
(#opened:inames)
(v: vprop)
(p: (t_of v -> Tot vprop))
(q: vprop)
: SteelGhost unit opened
(vdep v p)
(fun _ -> v `star` q)
(requires (fun h -> q == p (dfst (h (vdep v p)))))
(ensures (fun h _ h' ->
let fs = h' v in
let sn = h' q in
let x2 = h (vdep v p) in
q == p fs /\
dfst x2 == fs /\
dsnd x2 == sn
))
= change_slprop_rel_with_cond
(vdep v p)
(v `star` q)
(vdep_cond_recip v p q)
(vdep_rel_recip v q p)
(fun m -> elim_vdep_lemma v q p m);
reveal_star v q
let elim_vdep | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val elim_vdep (#opened:inames)
(v: vprop)
(p: (t_of v -> Tot vprop))
: SteelGhost (Ghost.erased (t_of v)) opened
(vdep v p)
(fun res -> v `star` p (Ghost.reveal res))
(requires (fun _ -> True))
(ensures (fun h res h' ->
let fs = h' v in
let sn : t_of (p (Ghost.reveal res)) = h' (p (Ghost.reveal res)) in
let x2 = h (vdep v p) in
Ghost.reveal res == fs /\
dfst x2 == fs /\
dsnd x2 == sn
)) | [] | Steel.Effect.Atomic.elim_vdep | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | v: Steel.Effect.Common.vprop -> p: (_: Steel.Effect.Common.t_of v -> Steel.Effect.Common.vprop)
-> Steel.Effect.Atomic.SteelGhost (FStar.Ghost.erased (Steel.Effect.Common.t_of v)) | {
"end_col": 5,
"end_line": 840,
"start_col": 1,
"start_line": 837
} |
Steel.Effect.Atomic.SteelGhost | val intro_vdep (#opened:inames)
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
: SteelGhost unit opened
(v `star` q)
(fun _ -> vdep v p)
(requires (fun h -> q == p (h v)))
(ensures (fun h _ h' ->
let x2 = h' (vdep v p) in
q == p (h v) /\
dfst x2 == (h v) /\
dsnd x2 == (h q)
)) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let intro_vdep
v q p
=
reveal_star v q;
change_slprop_rel_with_cond
(v `star` q)
(vdep v p)
(vdep_cond v q p)
(vdep_rel v q p)
(fun m -> intro_vdep_lemma v q p m) | val intro_vdep (#opened:inames)
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
: SteelGhost unit opened
(v `star` q)
(fun _ -> vdep v p)
(requires (fun h -> q == p (h v)))
(ensures (fun h _ h' ->
let x2 = h' (vdep v p) in
q == p (h v) /\
dfst x2 == (h v) /\
dsnd x2 == (h q)
))
let intro_vdep v q p = | true | null | false | reveal_star v q;
change_slprop_rel_with_cond (v `star` q)
(vdep v p)
(vdep_cond v q p)
(vdep_rel v q p)
(fun m -> intro_vdep_lemma v q p m) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.t_of",
"Steel.Effect.Atomic.change_slprop_rel_with_cond",
"Steel.Effect.Common.star",
"Steel.Effect.Common.vdep",
"Steel.Effect.Atomic.vdep_cond",
"Steel.Effect.Atomic.vdep_rel",
"Steel.Memory.mem",
"Steel.Effect.Atomic.intro_vdep_lemma",
"Prims.unit",
"Steel.Effect.Atomic.reveal_star"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p)
let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m)
let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m)
let witness_exists #a #u #p _ =
SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x)))
let lift_exists #a #u p =
as_atomic_action_ghost (Steel.Memory.lift_h_exists #u (fun x -> hp_of (p x)))
let exists_equiv p q =
Classical.forall_intro_2 reveal_equiv;
h_exists_cong (h_exists_sl' p) (h_exists_sl' q)
let exists_cong p q =
rewrite_slprop (h_exists p) (h_exists q)
(fun m ->
reveal_equiv (h_exists p) (h_exists q);
exists_equiv p q)
let fresh_invariant #uses p ctxt =
rewrite_slprop p (to_vprop (hp_of p)) (fun _ -> ());
let i = as_atomic_unobservable_action (fresh_invariant uses (hp_of p) ctxt) in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ());
return i
let new_invariant #uses p = let i = fresh_invariant #uses p [] in return i
(*
* AR: SteelAtomic and SteelGhost are not marked reifiable since we intend to run Steel programs natively
* However to implement the with_inv combinators we need to reify their thunks to reprs
* We could implement it better by having support for reification only in the .fst file
* But for now assuming a function
*)
assume val reify_steel_atomic_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames) (#g:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelAtomicBase a framed opened_invariants g pre post req ens)
: repr a framed opened_invariants g pre post req ens
[@@warn_on_use "as_unobservable_atomic_action is a trusted primitive"]
let as_atomic_o_action
(#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(o:observability)
(f:action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x))
= SteelAtomicBaseT?.reflect f
let with_invariant #a #fp #fp' #obs #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x = as_atomic_o_action obs
(Steel.Memory.with_invariant
#a
#(hp_of fp)
#(fun x -> hp_of (fp' x))
#opened
#(hp_of p)
i
(reify_steel_atomic_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return x
assume val reify_steel_ghost_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelGhostBase a framed opened_invariants Unobservable pre post req ens)
: repr a framed opened_invariants Unobservable pre post req ens
let with_invariant_g #a #fp #fp' #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x =
as_atomic_unobservable_action
(Steel.Memory.with_invariant #a #(hp_of fp) #(fun x -> hp_of (fp' x)) #opened #(hp_of p) i (reify_steel_ghost_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return (hide x)
let intro_vrefine v p =
let m = get () in
let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased (vrefine_t v p) = Ghost.hide (Ghost.reveal x) in
change_slprop
v
(vrefine v p)
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let elim_vrefine v p =
let h = get() in
let x : Ghost.erased (vrefine_t v p) = gget (vrefine v p) in
let x' : Ghost.erased (t_of v) = Ghost.hide (Ghost.reveal x) in
change_slprop
(vrefine v p)
v
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let vdep_cond
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
: Tot prop
= q == p (fst x1)
let vdep_rel
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
(x2: (t_of (vdep v p)))
: Tot prop
=
q == p (fst x1) /\
dfst (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == fst x1 /\
dsnd (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == snd x1
let intro_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (v `star` q)) m /\
q == p (fst (sel_of (v `star` q) m))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
))
=
Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m
let intro_vdep
v q p | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val intro_vdep (#opened:inames)
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
: SteelGhost unit opened
(v `star` q)
(fun _ -> vdep v p)
(requires (fun h -> q == p (h v)))
(ensures (fun h _ h' ->
let x2 = h' (vdep v p) in
q == p (h v) /\
dfst x2 == (h v) /\
dsnd x2 == (h q)
)) | [] | Steel.Effect.Atomic.intro_vdep | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
v: Steel.Effect.Common.vprop ->
q: Steel.Effect.Common.vprop ->
p: (_: Steel.Effect.Common.t_of v -> Steel.Effect.Common.vprop)
-> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 39,
"end_line": 770,
"start_col": 2,
"start_line": 764
} |
Steel.Effect.Atomic.SteelGhost | val intro_vrewrite (#opened:inames)
(v: vprop) (#t: Type) (f: (normal (t_of v) -> GTot t))
: SteelGhost unit opened v (fun _ -> vrewrite v f)
(fun _ -> True) (fun h _ h' -> h' (vrewrite v f) == f (h v)) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let intro_vrewrite
v #t f
= let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased t = Ghost.hide (f (Ghost.reveal x)) in
change_slprop
v
(vrewrite v f)
x
x'
(fun m ->
vrewrite_sel_eq v f m
) | val intro_vrewrite (#opened:inames)
(v: vprop) (#t: Type) (f: (normal (t_of v) -> GTot t))
: SteelGhost unit opened v (fun _ -> vrewrite v f)
(fun _ -> True) (fun h _ h' -> h' (vrewrite v f) == f (h v))
let intro_vrewrite v #t f = | true | null | false | let x:Ghost.erased (t_of v) = gget v in
let x':Ghost.erased t = Ghost.hide (f (Ghost.reveal x)) in
change_slprop v (vrewrite v f) x x' (fun m -> vrewrite_sel_eq v f m) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_of",
"Steel.Effect.Atomic.change_slprop",
"Steel.Effect.Common.vrewrite",
"Steel.Memory.mem",
"Steel.Effect.Common.vrewrite_sel_eq",
"Prims.unit",
"FStar.Ghost.erased",
"FStar.Ghost.hide",
"FStar.Ghost.reveal",
"Steel.Effect.Atomic.gget"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p)
let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m)
let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m)
let witness_exists #a #u #p _ =
SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x)))
let lift_exists #a #u p =
as_atomic_action_ghost (Steel.Memory.lift_h_exists #u (fun x -> hp_of (p x)))
let exists_equiv p q =
Classical.forall_intro_2 reveal_equiv;
h_exists_cong (h_exists_sl' p) (h_exists_sl' q)
let exists_cong p q =
rewrite_slprop (h_exists p) (h_exists q)
(fun m ->
reveal_equiv (h_exists p) (h_exists q);
exists_equiv p q)
let fresh_invariant #uses p ctxt =
rewrite_slprop p (to_vprop (hp_of p)) (fun _ -> ());
let i = as_atomic_unobservable_action (fresh_invariant uses (hp_of p) ctxt) in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ());
return i
let new_invariant #uses p = let i = fresh_invariant #uses p [] in return i
(*
* AR: SteelAtomic and SteelGhost are not marked reifiable since we intend to run Steel programs natively
* However to implement the with_inv combinators we need to reify their thunks to reprs
* We could implement it better by having support for reification only in the .fst file
* But for now assuming a function
*)
assume val reify_steel_atomic_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames) (#g:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelAtomicBase a framed opened_invariants g pre post req ens)
: repr a framed opened_invariants g pre post req ens
[@@warn_on_use "as_unobservable_atomic_action is a trusted primitive"]
let as_atomic_o_action
(#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(o:observability)
(f:action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x))
= SteelAtomicBaseT?.reflect f
let with_invariant #a #fp #fp' #obs #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x = as_atomic_o_action obs
(Steel.Memory.with_invariant
#a
#(hp_of fp)
#(fun x -> hp_of (fp' x))
#opened
#(hp_of p)
i
(reify_steel_atomic_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return x
assume val reify_steel_ghost_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelGhostBase a framed opened_invariants Unobservable pre post req ens)
: repr a framed opened_invariants Unobservable pre post req ens
let with_invariant_g #a #fp #fp' #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x =
as_atomic_unobservable_action
(Steel.Memory.with_invariant #a #(hp_of fp) #(fun x -> hp_of (fp' x)) #opened #(hp_of p) i (reify_steel_ghost_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return (hide x)
let intro_vrefine v p =
let m = get () in
let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased (vrefine_t v p) = Ghost.hide (Ghost.reveal x) in
change_slprop
v
(vrefine v p)
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let elim_vrefine v p =
let h = get() in
let x : Ghost.erased (vrefine_t v p) = gget (vrefine v p) in
let x' : Ghost.erased (t_of v) = Ghost.hide (Ghost.reveal x) in
change_slprop
(vrefine v p)
v
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let vdep_cond
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
: Tot prop
= q == p (fst x1)
let vdep_rel
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
(x2: (t_of (vdep v p)))
: Tot prop
=
q == p (fst x1) /\
dfst (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == fst x1 /\
dsnd (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == snd x1
let intro_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (v `star` q)) m /\
q == p (fst (sel_of (v `star` q) m))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
))
=
Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m
let intro_vdep
v q p
=
reveal_star v q;
change_slprop_rel_with_cond
(v `star` q)
(vdep v p)
(vdep_cond v q p)
(vdep_rel v q p)
(fun m -> intro_vdep_lemma v q p m)
let vdep_cond_recip
(v: vprop)
(p: (t_of v -> Tot vprop))
(q: vprop)
(x2: t_of (vdep v p))
: Tot prop
= q == p (dfst (x2 <: dtuple2 (t_of v) (vdep_payload v p)))
let vdep_rel_recip
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x2: (t_of (vdep v p)))
(x1: t_of (v `star` q))
: Tot prop
=
vdep_rel v q p x1 x2
let elim_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (vdep v p)) m /\
q == p (dfst (sel_of (vdep v p) m <: dtuple2 (t_of v) (vdep_payload v p)))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
))
=
Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m
let elim_vdep0
(#opened:inames)
(v: vprop)
(p: (t_of v -> Tot vprop))
(q: vprop)
: SteelGhost unit opened
(vdep v p)
(fun _ -> v `star` q)
(requires (fun h -> q == p (dfst (h (vdep v p)))))
(ensures (fun h _ h' ->
let fs = h' v in
let sn = h' q in
let x2 = h (vdep v p) in
q == p fs /\
dfst x2 == fs /\
dsnd x2 == sn
))
= change_slprop_rel_with_cond
(vdep v p)
(v `star` q)
(vdep_cond_recip v p q)
(vdep_rel_recip v q p)
(fun m -> elim_vdep_lemma v q p m);
reveal_star v q
let elim_vdep
v p
= let r = gget (vdep v p) in
let res = Ghost.hide (dfst #(t_of v) #(vdep_payload v p) (Ghost.reveal r)) in
elim_vdep0 v p (p (Ghost.reveal res));
res
let intro_vrewrite | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val intro_vrewrite (#opened:inames)
(v: vprop) (#t: Type) (f: (normal (t_of v) -> GTot t))
: SteelGhost unit opened v (fun _ -> vrewrite v f)
(fun _ -> True) (fun h _ h' -> h' (vrewrite v f) == f (h v)) | [] | Steel.Effect.Atomic.intro_vrewrite | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
v: Steel.Effect.Common.vprop ->
f: (_: Steel.Effect.Common.normal (Steel.Effect.Common.t_of v) -> Prims.GTot t)
-> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 5,
"end_line": 853,
"start_col": 1,
"start_line": 844
} |
Prims.Pure | val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y | val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
let bind_opaque
a
b
opened
o1
o2
#framed_f
#framed_g
#pre_f
#post_f
#req_f
#ens_f
#pre_g
#post_g
#req_g
#ens_g
#frame_f
#frame_g
#post
#_
#_
#p
#p2
f
g
= | false | null | false | fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem ((post_f x) `star` frame_f) (core_mem m1) in
let h1' = mk_rmem ((pre_g x) `star` (frame_g x)) (core_mem m1) in
can_be_split_trans ((post_f x) `star` frame_f) ((pre_g x) `star` (frame_g x)) (pre_g x);
focus_is_restrict_mk_rmem ((post_f x) `star` frame_f) ((pre_g x) `star` (frame_g x)) (core_mem m1);
focus_focus_is_focus ((post_f x) `star` frame_f)
((pre_g x) `star` (frame_g x))
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp (hp_of ((post_f x) `star` frame_f))
(hp_of ((pre_g x) `star` (frame_g x)))
frame
(locks_invariant opened m1)
m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans ((post_f x) `star` frame_f) ((pre_g x) `star` (frame_g x)) (pre_g x);
can_be_split_trans ((post_f x) `star` frame_f) ((pre_g x) `star` (frame_g x)) (frame_g x);
can_be_split_trans (post y) ((post_g x y) `star` (frame_g x)) (post_g x y);
can_be_split_trans (post y) ((post_g x y) `star` (frame_g x)) (frame_g x);
let h2' = mk_rmem ((post_g x y) `star` (frame_g x)) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
focus_focus_is_focus ((post_f x) `star` frame_f)
((pre_g x) `star` (frame_g x))
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem ((post_g x y) `star` (frame_g x)) (post y) (core_mem m2);
focus_focus_is_focus ((post_g x y) `star` (frame_g x)) (post y) (frame_g x) (core_mem m2);
focus_focus_is_focus ((post_g x y) `star` (frame_g x)) (post y) (post_g x y) (core_mem m2);
can_be_split_3_interp (hp_of ((post_g x y) `star` (frame_g x)))
(hp_of (post y))
frame
(locks_invariant opened m2)
m2;
y | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"FStar.Pervasives.eqtype_as_type",
"Steel.Effect.Common.observability",
"Prims.bool",
"Steel.Effect.Common.pre_t",
"Steel.Effect.Common.post_t",
"Steel.Effect.Common.req_t",
"Steel.Effect.Common.ens_t",
"Steel.Effect.Common.vprop",
"Prims.squash",
"Steel.Effect.Common.maybe_emp",
"Steel.Effect.Common.maybe_emp_dep",
"Prims.prop",
"Steel.Effect.Common.can_be_split_forall_dep",
"Steel.Effect.Common.star",
"Steel.Effect.Common.can_be_split_post",
"Steel.Effect.Atomic.repr",
"Steel.Memory.slprop",
"Prims.unit",
"Steel.Effect.can_be_split_3_interp",
"Steel.Effect.Common.hp_of",
"Steel.Memory.locks_invariant",
"Steel.Effect.focus_focus_is_focus",
"Steel.Memory.core_mem",
"Steel.Effect.focus_is_restrict_mk_rmem",
"Steel.Effect.Common.rmem'",
"Steel.Effect.Common.valid_rmem",
"Steel.Effect.Common.mk_rmem",
"Steel.Effect.Common.can_be_split_trans",
"Steel.Memory.full_mem",
"FStar.NMSTTotal.get",
"Steel.Memory.mem_evolves",
"Steel.Effect.Atomic.frame00",
"Prims._assert",
"Prims.eq2",
"Steel.Effect.Common.rmem",
"Steel.Effect.Common.focus_rmem"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20" | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True) | [] | Steel.Effect.Atomic.bind_opaque | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
a: Type ->
b: Type ->
opened_invariants: Steel.Memory.inames ->
o1: FStar.Pervasives.eqtype_as_type Steel.Effect.Common.observability ->
o2: FStar.Pervasives.eqtype_as_type Steel.Effect.Common.observability ->
f: Steel.Effect.Atomic.repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f ->
g:
(x: a
-> Steel.Effect.Atomic.repr b
framed_g
opened_invariants
o2
(pre_g x)
(post_g x)
(req_g x)
(ens_g x))
-> Prims.Pure
(Steel.Effect.Atomic.repr b
true
opened_invariants
(Steel.Effect.Common.join_obs o1 o2)
(Steel.Effect.Common.star pre_f frame_f)
post
(Steel.Effect.Atomic.bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(Steel.Effect.Atomic.bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)) | {
"end_col": 5,
"end_line": 271,
"start_col": 2,
"start_line": 197
} |
Steel.Effect.Atomic.SteelGhost | val intro_vrefine (#opened:inames)
(v: vprop) (p: (normal (t_of v) -> Tot prop))
: SteelGhost unit opened v (fun _ -> vrefine v p)
(requires fun h -> p (h v))
(ensures fun h _ h' -> h' (vrefine v p) == h v) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let intro_vrefine v p =
let m = get () in
let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased (vrefine_t v p) = Ghost.hide (Ghost.reveal x) in
change_slprop
v
(vrefine v p)
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
) | val intro_vrefine (#opened:inames)
(v: vprop) (p: (normal (t_of v) -> Tot prop))
: SteelGhost unit opened v (fun _ -> vrefine v p)
(requires fun h -> p (h v))
(ensures fun h _ h' -> h' (vrefine v p) == h v)
let intro_vrefine v p = | true | null | false | let m = get () in
let x:Ghost.erased (t_of v) = gget v in
let x':Ghost.erased (vrefine_t v p) = Ghost.hide (Ghost.reveal x) in
change_slprop v
(vrefine v p)
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m) | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_of",
"Prims.prop",
"Steel.Effect.Atomic.change_slprop",
"Steel.Effect.Common.vrefine",
"Steel.Memory.mem",
"Steel.Effect.Common.vrefine_sel_eq",
"Prims.unit",
"Steel.Effect.Common.interp_vrefine_hp",
"FStar.Ghost.erased",
"Steel.Effect.Common.vrefine_t",
"FStar.Ghost.hide",
"FStar.Ghost.reveal",
"Steel.Effect.Atomic.gget",
"Steel.Effect.Common.rmem'",
"Steel.Effect.Common.valid_rmem",
"Steel.Effect.Atomic.get",
"Steel.Effect.Common.rmem"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p)
let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m)
let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m)
let witness_exists #a #u #p _ =
SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x)))
let lift_exists #a #u p =
as_atomic_action_ghost (Steel.Memory.lift_h_exists #u (fun x -> hp_of (p x)))
let exists_equiv p q =
Classical.forall_intro_2 reveal_equiv;
h_exists_cong (h_exists_sl' p) (h_exists_sl' q)
let exists_cong p q =
rewrite_slprop (h_exists p) (h_exists q)
(fun m ->
reveal_equiv (h_exists p) (h_exists q);
exists_equiv p q)
let fresh_invariant #uses p ctxt =
rewrite_slprop p (to_vprop (hp_of p)) (fun _ -> ());
let i = as_atomic_unobservable_action (fresh_invariant uses (hp_of p) ctxt) in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ());
return i
let new_invariant #uses p = let i = fresh_invariant #uses p [] in return i
(*
* AR: SteelAtomic and SteelGhost are not marked reifiable since we intend to run Steel programs natively
* However to implement the with_inv combinators we need to reify their thunks to reprs
* We could implement it better by having support for reification only in the .fst file
* But for now assuming a function
*)
assume val reify_steel_atomic_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames) (#g:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelAtomicBase a framed opened_invariants g pre post req ens)
: repr a framed opened_invariants g pre post req ens
[@@warn_on_use "as_unobservable_atomic_action is a trusted primitive"]
let as_atomic_o_action
(#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(o:observability)
(f:action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x))
= SteelAtomicBaseT?.reflect f
let with_invariant #a #fp #fp' #obs #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x = as_atomic_o_action obs
(Steel.Memory.with_invariant
#a
#(hp_of fp)
#(fun x -> hp_of (fp' x))
#opened
#(hp_of p)
i
(reify_steel_atomic_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return x
assume val reify_steel_ghost_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelGhostBase a framed opened_invariants Unobservable pre post req ens)
: repr a framed opened_invariants Unobservable pre post req ens
let with_invariant_g #a #fp #fp' #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x =
as_atomic_unobservable_action
(Steel.Memory.with_invariant #a #(hp_of fp) #(fun x -> hp_of (fp' x)) #opened #(hp_of p) i (reify_steel_ghost_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return (hide x) | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val intro_vrefine (#opened:inames)
(v: vprop) (p: (normal (t_of v) -> Tot prop))
: SteelGhost unit opened v (fun _ -> vrefine v p)
(requires fun h -> p (h v))
(ensures fun h _ h' -> h' (vrefine v p) == h v) | [] | Steel.Effect.Atomic.intro_vrefine | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
v: Steel.Effect.Common.vprop ->
p: (_: Steel.Effect.Common.normal (Steel.Effect.Common.t_of v) -> Prims.prop)
-> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 5,
"end_line": 705,
"start_col": 23,
"start_line": 693
} |
Steel.Effect.Atomic.SteelGhost | val mk_selector_vprop_elim
(#opened: _) (#t: Type0)
(p: t -> vprop) (p_inj: interp_hp_of_injective p)
: SteelGhost (Ghost.erased t) opened
(mk_selector_vprop p p_inj)
(fun x -> p x)
(fun _ -> True)
(fun h x _ -> h (mk_selector_vprop p p_inj) == Ghost.reveal x) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mk_selector_vprop_elim
#_ #t p p_inj
=
let x0 = gget (mk_selector_vprop p p_inj) in
let refinement (x: t) : Tot prop = x == Ghost.reveal x0 in
intro_vrefine (mk_selector_vprop p p_inj) refinement;
rewrite_slprop
(mk_selector_vprop p p_inj `vrefine` refinement)
(p x0)
(fun m ->
interp_vrefine_hp (mk_selector_vprop p p_inj) refinement m
// injectivity is not needed, because the return value of the
// selector is exactly the witness of exists_
);
x0 | val mk_selector_vprop_elim
(#opened: _) (#t: Type0)
(p: t -> vprop) (p_inj: interp_hp_of_injective p)
: SteelGhost (Ghost.erased t) opened
(mk_selector_vprop p p_inj)
(fun x -> p x)
(fun _ -> True)
(fun h x _ -> h (mk_selector_vprop p p_inj) == Ghost.reveal x)
let mk_selector_vprop_elim #_ #t p p_inj = | true | null | false | let x0 = gget (mk_selector_vprop p p_inj) in
let refinement (x: t) : Tot prop = x == Ghost.reveal x0 in
intro_vrefine (mk_selector_vprop p p_inj) refinement;
rewrite_slprop ((mk_selector_vprop p p_inj) `vrefine` refinement)
(p x0)
(fun m -> interp_vrefine_hp (mk_selector_vprop p p_inj) refinement m);
x0 | {
"checked_file": "Steel.Effect.Atomic.fst.checked",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Effect.Atomic.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.interp_hp_of_injective",
"FStar.Ghost.erased",
"Prims.unit",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.Effect.Common.vrefine",
"Steel.Effect.Atomic.mk_selector_vprop",
"FStar.Ghost.reveal",
"Steel.Effect.Common.t_of",
"Steel.Memory.mem",
"Steel.Effect.Common.interp_vrefine_hp",
"Steel.Effect.Atomic.intro_vrefine",
"Prims.prop",
"Prims.eq2",
"Steel.Effect.Atomic.gget"
] | [] | (*
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.Effect.Atomic
open Steel.Effect
friend Steel.Effect
#set-options "--warn_error -330" //turn off the experimental feature warning
let _ : squash (forall (pre:pre_t) (m0:mem{interp (hp_of pre) m0}) (m1:mem{disjoint m0 m1}).
mk_rmem pre m0 == mk_rmem pre (join m0 m1)) = Classical.forall_intro rmem_depends_only_on
let req_to_act_req (#pre:vprop) (req:req_t pre) : mprop (hp_of pre) =
fun m ->
rmem_depends_only_on pre;
interp (hp_of pre) m /\ req (mk_rmem pre m)
unfold
let to_post (#a:Type) (post:post_t a) = fun x -> (hp_of (post x))
let ens_to_act_ens (#pre:pre_t) (#a:Type) (#post:post_t a) (ens:ens_t pre a post)
: mprop2 (hp_of pre) (to_post post)
= fun m0 x m1 -> interp (hp_of pre) m0 /\ interp (hp_of (post x)) m1 /\
ens (mk_rmem pre m0) x (mk_rmem (post x) m1)
let repr a framed opened f pre post req ens =
action_except_full a opened (hp_of pre) (to_post post)
(req_to_act_req req) (ens_to_act_ens ens)
let return_ a x opened #p = fun _ ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (p x) (core_mem m0) in
lemma_frame_equalities_refl (p x) h0;
x
#push-options "--fuel 0 --ifuel 0"
#push-options "--z3rlimit 20 --fuel 1 --ifuel 1"
val frame00 (#a:Type)
(#framed:bool)
(#opened:inames)
(#obs:observability)
(#pre:pre_t)
(#post:post_t a)
(#req:req_t pre)
(#ens:ens_t pre a post)
($f:repr a framed opened obs pre post req ens)
(frame:vprop)
: repr a
true
opened
obs
(pre `star` frame)
(fun x -> post x `star` frame)
(fun h -> req (focus_rmem h pre))
(fun h0 r h1 -> req (focus_rmem h0 pre) /\ ens (focus_rmem h0 pre) r (focus_rmem h1 (post r)) /\
frame_opaque frame (focus_rmem h0 frame) (focus_rmem h1 frame))
module Sem = Steel.Semantics.Hoare.MST
module Mem = Steel.Memory
let equiv_middle_left_assoc (a b c d:slprop)
: Lemma (((a `Mem.star` b) `Mem.star` c `Mem.star` d) `Mem.equiv`
(a `Mem.star` (b `Mem.star` c) `Mem.star` d))
= let open Steel.Memory in
star_associative a b c;
star_congruence ((a `star` b) `star` c) d (a `star` (b `star` c)) d
let frame00 #a #framed #opened #obs #pre #post #req #ens f frame =
fun frame' ->
let m0:full_mem = NMSTTotal.get () in
let snap:rmem frame = mk_rmem frame (core_mem m0) in
// Need to define it with type annotation, although unused, for it to trigger
// the pattern on the framed ensures in the def of MstTot
let aux:mprop (hp_of frame `Mem.star` frame') = req_frame frame snap in
focus_is_restrict_mk_rmem (pre `star` frame) pre (core_mem m0);
assert (interp (hp_of (pre `star` frame) `Mem.star` frame' `Mem.star` locks_invariant opened m0) m0);
equiv_middle_left_assoc (hp_of pre) (hp_of frame) frame' (locks_invariant opened m0);
assert (interp (hp_of pre `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m0) m0);
let x = f (hp_of frame `Mem.star` frame') in
let m1:full_mem = NMSTTotal.get () in
assert (interp (hp_of (post x) `Mem.star` (hp_of frame `Mem.star` frame') `Mem.star` locks_invariant opened m1) m1);
equiv_middle_left_assoc (hp_of (post x)) (hp_of frame) frame' (locks_invariant opened m1);
assert (interp ((hp_of (post x) `Mem.star` hp_of frame)
`Mem.star` frame' `Mem.star` locks_invariant opened m1) m1);
focus_is_restrict_mk_rmem (pre `star` frame) frame (core_mem m0);
focus_is_restrict_mk_rmem (post x `star` frame) frame (core_mem m1);
let h0:rmem (pre `star` frame) = mk_rmem (pre `star` frame) (core_mem m0) in
let h1:rmem (post x `star` frame) = mk_rmem (post x `star` frame) (core_mem m1) in
assert (focus_rmem h0 frame == focus_rmem h1 frame);
focus_is_restrict_mk_rmem (post x `star` frame) (post x) (core_mem m1);
lemma_frame_opaque_refl frame (focus_rmem h0 frame);
x
unfold
let bind_req_opaque (#a:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t)
(#pr:a -> prop)
(req_g:(x:a -> req_t (pre_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
: req_t (pre_f `star` frame_f)
= fun m0 ->
req_f (focus_rmem m0 pre_f) /\
(forall (x:a) (h1:hmem (post_f x `star` frame_f)).
(ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f))
==> pr x /\
(can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
(req_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x))))
unfold
let bind_ens_opaque (#a:Type) (#b:Type)
(#pre_f:pre_t) (#post_f:post_t a)
(req_f:req_t pre_f) (ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#pr:a -> prop)
(ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(frame_f:vprop) (frame_g:a -> vprop)
(post:post_t b)
(_:squash (can_be_split_forall_dep pr (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(_:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
: ens_t (pre_f `star` frame_f) b post
= fun m0 y m2 ->
req_f (focus_rmem m0 pre_f) /\
(exists (x:a) (h1:hmem (post_f x `star` frame_f)).
pr x /\
(
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
frame_opaque frame_f (focus_rmem m0 frame_f) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) frame_f) /\
frame_opaque (frame_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (frame_g x)) (focus_rmem m2 (frame_g x)) /\
ens_f (focus_rmem m0 pre_f) x (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (post_f x)) /\
(ens_g x) (focus_rmem (mk_rmem (post_f x `star` frame_f) h1) (pre_g x)) y (focus_rmem m2 (post_g x y))))
val bind_opaque (a:Type) (b:Type)
(opened_invariants:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#pre_f:pre_t) (#post_f:post_t a)
(#req_f:req_t pre_f) (#ens_f:ens_t pre_f a post_f)
(#pre_g:a -> pre_t) (#post_g:a -> post_t b)
(#req_g:(x:a -> req_t (pre_g x))) (#ens_g:(x:a -> ens_t (pre_g x) b (post_g x)))
(#frame_f:vprop) (#frame_g:a -> vprop)
(#post:post_t b)
(# _ : squash (maybe_emp framed_f frame_f))
(# _ : squash (maybe_emp_dep framed_g frame_g))
(#pr:a -> prop)
(#p1:squash (can_be_split_forall_dep pr
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g x)))
(#p2:squash (can_be_split_post (fun x y -> post_g x y `star` frame_g x) post))
(f:repr a framed_f opened_invariants o1 pre_f post_f req_f ens_f)
(g:(x:a -> repr b framed_g opened_invariants o2 (pre_g x) (post_g x) (req_g x) (ens_g x)))
: Pure (repr b true opened_invariants (join_obs o1 o2)
(pre_f `star` frame_f)
post
(bind_req_opaque req_f ens_f req_g frame_f frame_g p1)
(bind_ens_opaque req_f ens_f ens_g frame_f frame_g post p1 p2)
)
(requires obs_at_most_one o1 o2)
(ensures fun _ -> True)
#push-options "--z3rlimit 20"
let bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem (pre_f `star` frame_f) (core_mem m0) in
let x = frame00 f frame_f frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_f x `star` frame_f) (core_mem m1) in
let h1' = mk_rmem (pre_g x `star` frame_g x) (core_mem m1) in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
focus_is_restrict_mk_rmem
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(core_mem m1);
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(pre_g x)
(core_mem m1);
assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
can_be_split_3_interp
(hp_of (post_f x `star` frame_f))
(hp_of (pre_g x `star` frame_g x))
frame (locks_invariant opened m1) m1;
let y = frame00 (g x) (frame_g x) frame in
let m2:full_mem = NMSTTotal.get () in
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (pre_g x);
can_be_split_trans (post_f x `star` frame_f) (pre_g x `star` frame_g x) (frame_g x);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (post_g x y);
can_be_split_trans (post y) (post_g x y `star` frame_g x) (frame_g x);
let h2' = mk_rmem (post_g x y `star` frame_g x) (core_mem m2) in
let h2 = mk_rmem (post y) (core_mem m2) in
// assert (focus_rmem h1' (pre_g x) == focus_rmem h1 (pre_g x));
focus_focus_is_focus
(post_f x `star` frame_f)
(pre_g x `star` frame_g x)
(frame_g x)
(core_mem m1);
focus_is_restrict_mk_rmem
(post_g x y `star` frame_g x)
(post y)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(frame_g x)
(core_mem m2);
focus_focus_is_focus
(post_g x y `star` frame_g x)
(post y)
(post_g x y)
(core_mem m2);
can_be_split_3_interp
(hp_of (post_g x y `star` frame_g x))
(hp_of (post y))
frame (locks_invariant opened m2) m2;
y
let norm_repr (#a:Type) (#framed:bool) (#opened:inames) (#obs:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
(f:repr a framed opened obs pre post req ens)
: repr a framed opened obs pre post (fun h -> norm_opaque (req h)) (fun h0 x h1 -> norm_opaque (ens h0 x h1))
= f
let bind a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g
= norm_repr (bind_opaque a b opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #frame_f #frame_g #post #_ #_ #p #p2 f g)
val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@ framing_implicit] ens_f:ens_t pre_f a post_f)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] req_g:req_t pre_g) (#[@@@ framing_implicit] ens_g:ens_t pre_g a post_g)
(#[@@@ framing_implicit] frame:vprop)
(#[@@@ framing_implicit] pr : prop)
(#[@@@ framing_implicit] _ : squash (maybe_emp framed_f frame))
(#[@@@ framing_implicit] p1:squash (can_be_split_dep pr pre_g (pre_f `star` frame)))
(#[@@@ framing_implicit] p2:squash (equiv_forall post_g (fun x -> post_f x `star` frame)))
(f:repr a framed_f opened o1 pre_f post_f req_f ens_f)
: Pure (repr a framed_g opened o2 pre_g post_g req_g ens_g)
(requires (o1 = Unobservable || o2 = Observable) /\
subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2)
(ensures fun _ -> True)
let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g (pre_f `star` fr) pre_f (core_mem m0);
let x = frame00 f fr frame in
let m1:full_mem = NMSTTotal.get () in
let h1 = mk_rmem (post_g x) (core_mem m1) in
let h0' = mk_rmem (pre_f `star` fr) (core_mem m0) in
let h1' = mk_rmem (post_f x `star` fr) (core_mem m1) in
// From frame00
assert (frame_opaque fr (focus_rmem h0' fr) (focus_rmem h1' fr));
// Replace h0'/h1' by h0/h1
focus_replace pre_g (pre_f `star` fr) fr (core_mem m0);
focus_replace (post_g x) (post_f x `star` fr) fr (core_mem m1);
assert (frame_opaque fr (focus_rmem h0 fr) (focus_rmem h1 fr));
can_be_split_trans (post_g x) (post_f x `star` fr) (post_f x);
can_be_split_trans (post_g x) (post_f x `star` fr) fr;
can_be_split_3_interp (hp_of (post_f x `star` fr)) (hp_of (post_g x)) frame (locks_invariant opened m1) m1;
focus_replace (post_g x) (post_f x `star` fr) (post_f x) (core_mem m1);
x
let subcomp a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #_ #pr #p1 #p2 f =
lemma_subcomp_pre_opaque req_f ens_f req_g ens_g p1 p2;
subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f
#pop-options
let bind_pure_steela_ a b opened o #wp f g
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun frame ->
let x = f () in
g x frame
let lift_ghost_atomic a o f = f
let lift_atomic_steel a o f = f
let as_atomic_action f = SteelAtomic?.reflect f
let as_atomic_action_ghost f = SteelGhost?.reflect f
let as_atomic_unobservable_action f = SteelAtomicU?.reflect f
(* Some helpers *)
let get0 (#opened:inames) (#p:vprop) (_:unit) : repr (erased (rmem p))
true opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1 /\ frame_equalities p r h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
h0
let get () = SteelGhost?.reflect (get0 ())
let intro_star (p q:vprop) (r:slprop) (vp:erased (t_of p)) (vq:erased (t_of q)) (m:mem)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m)
)
: Lemma
(requires interp ((hp_of p) `Mem.star` r) m /\ sel_of p m == reveal vp)
(ensures interp ((hp_of q) `Mem.star` r) m)
= let p = hp_of p in
let q = hp_of q in
let intro (ml mr:mem) : Lemma
(requires interp q ml /\ interp r mr /\ disjoint ml mr)
(ensures disjoint ml mr /\ interp (q `Mem.star` r) (Mem.join ml mr))
= Mem.intro_star q r ml mr
in
elim_star p r m;
Classical.forall_intro (Classical.move_requires proof);
Classical.forall_intro_2 (Classical.move_requires_2 intro)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let rewrite_slprop0 (#opened:inames) (p q:vprop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ _ -> True)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) (sel_of q m) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let rewrite_slprop p q l = SteelGhost?.reflect (rewrite_slprop0 p q l)
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop0 (#opened:inames) (p q:vprop) (vp:erased (t_of p)) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q) (fun h -> h p == reveal vp) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) vp vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop p q vp vq l = SteelGhost?.reflect (change_slprop0 p q vp vq l)
let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ())
#push-options "--z3rlimit 20 --fuel 1 --ifuel 0"
let change_slprop_20 (#opened:inames) (p q:vprop) (vq:erased (t_of q))
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures interp (hp_of q) m /\ sel_of q m == reveal vq)
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun _ _ h1 -> h1 q == reveal vq)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
Classical.forall_intro (Classical.move_requires proof);
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p m) vq m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
#pop-options
let change_slprop_2 p q vq l = SteelGhost?.reflect (change_slprop_20 p q vq l)
let change_slprop_rel0 (#opened:inames) (p q:vprop)
(rel : normal (t_of p) -> normal (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun _ -> True) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel p q rel proof = SteelGhost?.reflect (change_slprop_rel0 p q rel proof)
let change_slprop_rel_with_cond0 (#opened:inames) (p q:vprop)
(cond: t_of p -> prop)
(rel : (t_of p) -> (t_of q) -> prop)
(proof:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ cond (sel_of p m))
(ensures
interp (hp_of p) m /\
interp (hp_of q) m /\
rel (sel_of p m) (sel_of q m))
) : repr unit false opened Unobservable p (fun _ -> q)
(fun m -> cond (m p)) (fun h0 _ h1 -> rel (h0 p) (h1 q))
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
proof (core_mem m);
let h0 = mk_rmem p (core_mem m) in
let h1 = mk_rmem q (core_mem m) in
reveal_mk_rmem p (core_mem m) p;
reveal_mk_rmem q (core_mem m) q;
Mem.star_associative (hp_of p) frame (locks_invariant opened m);
intro_star p q (frame `Mem.star` locks_invariant opened m) (sel_of p (core_mem m)) (sel_of q (core_mem m)) m proof;
Mem.star_associative (hp_of q) frame (locks_invariant opened m)
let change_slprop_rel_with_cond p q cond rel proof
= SteelGhost?.reflect (change_slprop_rel_with_cond0 p q cond rel proof)
let extract_info0 (#opened:inames) (p:vprop) (vp:erased (normal (t_of p))) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m /\ sel_of p m == reveal vp)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> h p == reveal vp)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info p vp fact l = SteelGhost?.reflect (extract_info0 p vp fact l)
let extract_info_raw0 (#opened:inames) (p:vprop) (fact:prop)
(l:(m:mem) -> Lemma
(requires interp (hp_of p) m)
(ensures fact)
) : repr unit false opened Unobservable p (fun _ -> p)
(fun h -> True)
(fun h0 _ h1 -> frame_equalities p h0 h1 /\ fact)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0;
l (core_mem m0)
let extract_info_raw p fact l = SteelGhost?.reflect (extract_info_raw0 p fact l)
let noop _ = change_slprop_rel emp emp (fun _ _ -> True) (fun _ -> ())
let sladmit _ = SteelGhostF?.reflect (fun _ -> NMSTTotal.nmst_tot_admit ())
let slassert0 (#opened:inames) (p:vprop) : repr unit
false opened Unobservable p (fun _ -> p)
(requires fun _ -> True)
(ensures fun h0 r h1 -> frame_equalities p h0 h1)
= fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem p (core_mem m0) in
lemma_frame_equalities_refl p h0
let slassert p = SteelGhost?.reflect (slassert0 p)
let drop p = rewrite_slprop p emp
(fun m -> emp_unit (hp_of p); affine_star (hp_of p) Mem.emp m; reveal_emp())
let reveal_star0 (#opened:inames) (p1 p2:vprop)
: repr unit false opened Unobservable (p1 `star` p2) (fun _ -> p1 `star` p2)
(fun _ -> True)
(fun h0 _ h1 ->
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\
h0 (p1 `star` p2) == (h0 p1, h0 p2) /\
h1 (p1 `star` p2) == (h1 p1, h1 p2)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem
let reveal_star p1 p2 = SteelGhost?.reflect (reveal_star0 p1 p2)
let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 == h1 p2 /\ h0 p3 == h1 p3 /\
h0 (p1 `star` p2 `star` p3) == ((h0 p1, h0 p2), h0 p3) /\
h1 (p1 `star` p2 `star` p3) == ((h1 p1, h1 p2), h1 p3)
)
= fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem (p1 `star` p2 `star` p3) (core_mem m) in
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p1;
can_be_split_trans (p1 `star` p2 `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2 `star` p3);
reveal_mk_rmem (p1 `star` p2 `star` p3) m (p1 `star` p2);
reveal_mk_rmem (p1 `star` p2 `star` p3) m p3
let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3)
let intro_pure p = rewrite_slprop emp (pure p) (fun m -> pure_interp p m)
let elim_pure_aux #uses (p:prop)
: SteelGhostT (_:unit{p}) uses (pure p) (fun _ -> to_vprop Mem.emp)
= as_atomic_action_ghost (Steel.Memory.elim_pure #uses p)
let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ())
let return #a #opened #p x = SteelAtomicBase?.reflect (return_ a x opened #p)
let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m)
let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m)
let witness_exists #a #u #p _ =
SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x)))
let lift_exists #a #u p =
as_atomic_action_ghost (Steel.Memory.lift_h_exists #u (fun x -> hp_of (p x)))
let exists_equiv p q =
Classical.forall_intro_2 reveal_equiv;
h_exists_cong (h_exists_sl' p) (h_exists_sl' q)
let exists_cong p q =
rewrite_slprop (h_exists p) (h_exists q)
(fun m ->
reveal_equiv (h_exists p) (h_exists q);
exists_equiv p q)
let fresh_invariant #uses p ctxt =
rewrite_slprop p (to_vprop (hp_of p)) (fun _ -> ());
let i = as_atomic_unobservable_action (fresh_invariant uses (hp_of p) ctxt) in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ());
return i
let new_invariant #uses p = let i = fresh_invariant #uses p [] in return i
(*
* AR: SteelAtomic and SteelGhost are not marked reifiable since we intend to run Steel programs natively
* However to implement the with_inv combinators we need to reify their thunks to reprs
* We could implement it better by having support for reification only in the .fst file
* But for now assuming a function
*)
assume val reify_steel_atomic_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames) (#g:observability)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelAtomicBase a framed opened_invariants g pre post req ens)
: repr a framed opened_invariants g pre post req ens
[@@warn_on_use "as_unobservable_atomic_action is a trusted primitive"]
let as_atomic_o_action
(#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(o:observability)
(f:action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x))
= SteelAtomicBaseT?.reflect f
let with_invariant #a #fp #fp' #obs #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x = as_atomic_o_action obs
(Steel.Memory.with_invariant
#a
#(hp_of fp)
#(fun x -> hp_of (fp' x))
#opened
#(hp_of p)
i
(reify_steel_atomic_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return x
assume val reify_steel_ghost_comp
(#a:Type) (#framed:bool) (#opened_invariants:inames)
(#pre:pre_t) (#post:post_t a) (#req:req_t pre) (#ens:ens_t pre a post)
($f:unit -> SteelGhostBase a framed opened_invariants Unobservable pre post req ens)
: repr a framed opened_invariants Unobservable pre post req ens
let with_invariant_g #a #fp #fp' #opened #p i f =
rewrite_slprop fp (to_vprop (hp_of fp)) (fun _ -> ());
let x =
as_atomic_unobservable_action
(Steel.Memory.with_invariant #a #(hp_of fp) #(fun x -> hp_of (fp' x)) #opened #(hp_of p) i (reify_steel_ghost_comp f)) in
rewrite_slprop (to_vprop (hp_of (fp' x))) (fp' x) (fun _ -> ());
return (hide x)
let intro_vrefine v p =
let m = get () in
let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased (vrefine_t v p) = Ghost.hide (Ghost.reveal x) in
change_slprop
v
(vrefine v p)
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let elim_vrefine v p =
let h = get() in
let x : Ghost.erased (vrefine_t v p) = gget (vrefine v p) in
let x' : Ghost.erased (t_of v) = Ghost.hide (Ghost.reveal x) in
change_slprop
(vrefine v p)
v
x
x'
(fun m ->
interp_vrefine_hp v p m;
vrefine_sel_eq v p m
)
let vdep_cond
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
: Tot prop
= q == p (fst x1)
let vdep_rel
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x1: t_of (v `star` q))
(x2: (t_of (vdep v p)))
: Tot prop
=
q == p (fst x1) /\
dfst (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == fst x1 /\
dsnd (x2 <: (dtuple2 (t_of v) (vdep_payload v p))) == snd x1
let intro_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (v `star` q)) m /\
q == p (fst (sel_of (v `star` q) m))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
))
=
Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m
let intro_vdep
v q p
=
reveal_star v q;
change_slprop_rel_with_cond
(v `star` q)
(vdep v p)
(vdep_cond v q p)
(vdep_rel v q p)
(fun m -> intro_vdep_lemma v q p m)
let vdep_cond_recip
(v: vprop)
(p: (t_of v -> Tot vprop))
(q: vprop)
(x2: t_of (vdep v p))
: Tot prop
= q == p (dfst (x2 <: dtuple2 (t_of v) (vdep_payload v p)))
let vdep_rel_recip
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(x2: (t_of (vdep v p)))
(x1: t_of (v `star` q))
: Tot prop
=
vdep_rel v q p x1 x2
let elim_vdep_lemma
(v: vprop)
(q: vprop)
(p: (t_of v -> Tot vprop))
(m: mem)
: Lemma
(requires (
interp (hp_of (vdep v p)) m /\
q == p (dfst (sel_of (vdep v p) m <: dtuple2 (t_of v) (vdep_payload v p)))
))
(ensures (
interp (hp_of (v `star` q)) m /\
interp (hp_of (vdep v p)) m /\
vdep_rel v q p (sel_of (v `star` q) m) (sel_of (vdep v p) m)
))
=
Mem.interp_star (hp_of v) (hp_of q) m;
interp_vdep_hp v p m;
vdep_sel_eq v p m
let elim_vdep0
(#opened:inames)
(v: vprop)
(p: (t_of v -> Tot vprop))
(q: vprop)
: SteelGhost unit opened
(vdep v p)
(fun _ -> v `star` q)
(requires (fun h -> q == p (dfst (h (vdep v p)))))
(ensures (fun h _ h' ->
let fs = h' v in
let sn = h' q in
let x2 = h (vdep v p) in
q == p fs /\
dfst x2 == fs /\
dsnd x2 == sn
))
= change_slprop_rel_with_cond
(vdep v p)
(v `star` q)
(vdep_cond_recip v p q)
(vdep_rel_recip v q p)
(fun m -> elim_vdep_lemma v q p m);
reveal_star v q
let elim_vdep
v p
= let r = gget (vdep v p) in
let res = Ghost.hide (dfst #(t_of v) #(vdep_payload v p) (Ghost.reveal r)) in
elim_vdep0 v p (p (Ghost.reveal res));
res
let intro_vrewrite
v #t f
= let x : Ghost.erased (t_of v) = gget v in
let x' : Ghost.erased t = Ghost.hide (f (Ghost.reveal x)) in
change_slprop
v
(vrewrite v f)
x
x'
(fun m ->
vrewrite_sel_eq v f m
)
let elim_vrewrite
v #t f
=
change_slprop_rel
(vrewrite v f)
v
(fun y x -> y == f x)
(fun m -> vrewrite_sel_eq v f m)
/// Deriving a selector-style vprop from an injective pts-to-style vprop
let hp_of_pointwise
(#t: Type)
(p: t -> vprop)
(x: t)
: Tot slprop
= hp_of (p x)
let mk_selector_vprop_hp
p
= Steel.Memory.h_exists (hp_of_pointwise p)
let mk_selector_vprop_sel'
(#t: Type)
(p: t -> vprop)
(p_inj: interp_hp_of_injective p) // unused in the definition, but necessary for the local SMTPats below
: Tot (selector' t (mk_selector_vprop_hp p))
= fun m -> id_elim_exists (hp_of_pointwise p) m
let mk_selector_vprop_sel
#t p p_inj
=
let varrayp_sel_depends_only_on
(#t: Type)
(p: t -> vprop)
(p_inj: interp_hp_of_injective p)
(m0: Steel.Memory.hmem (mk_selector_vprop_hp p))
(m1: mem { disjoint m0 m1 })
: Lemma
(
mk_selector_vprop_sel' p p_inj m0 == mk_selector_vprop_sel' p p_inj (Steel.Memory.join m0 m1)
)
[SMTPat (mk_selector_vprop_sel' p p_inj (Steel.Memory.join m0 m1))]
= p_inj (mk_selector_vprop_sel' p p_inj m0) (mk_selector_vprop_sel' p p_inj (Steel.Memory.join m0 m1)) (Steel.Memory.join m0 m1)
in
let varrayp_sel_depends_only_on_core
(#t: Type)
(p: t -> vprop)
(p_inj: interp_hp_of_injective p)
(m0: Steel.Memory.hmem (mk_selector_vprop_hp p))
: Lemma
(
mk_selector_vprop_sel' p p_inj m0 == mk_selector_vprop_sel' p p_inj (core_mem m0)
)
[SMTPat (mk_selector_vprop_sel' p p_inj (core_mem m0))]
= p_inj (mk_selector_vprop_sel' p p_inj m0) (mk_selector_vprop_sel' p p_inj (core_mem m0)) m0
in
mk_selector_vprop_sel' p p_inj
let mk_selector_vprop_intro
#_ #_ #x p p_inj
= change_slprop_rel
(p _)
(mk_selector_vprop p p_inj)
(fun _ x' -> x == x')
(fun m ->
intro_h_exists x (hp_of_pointwise p) m;
let x' = mk_selector_vprop_sel' p p_inj m in
p_inj x x' m
)
let mk_selector_vprop_elim | false | false | Steel.Effect.Atomic.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mk_selector_vprop_elim
(#opened: _) (#t: Type0)
(p: t -> vprop) (p_inj: interp_hp_of_injective p)
: SteelGhost (Ghost.erased t) opened
(mk_selector_vprop p p_inj)
(fun x -> p x)
(fun _ -> True)
(fun h x _ -> h (mk_selector_vprop p p_inj) == Ghost.reveal x) | [] | Steel.Effect.Atomic.mk_selector_vprop_elim | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: (_: t -> Steel.Effect.Common.vprop) -> p_inj: Steel.Effect.Atomic.interp_hp_of_injective p
-> Steel.Effect.Atomic.SteelGhost (FStar.Ghost.erased t) | {
"end_col": 4,
"end_line": 940,
"start_col": 1,
"start_line": 928
} |
FStar.Tactics.Effect.Tac | val pp_record (flds: list (string & document)) : Tac document | [
{
"abbrev": false,
"full_module": "Pulse.Show",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Printer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Pprint",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Typeclasses",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Pprint",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let pp_record (flds : list (string & document)) : Tac document =
let flds_doc =
separate_map (doc_of_string ";") (fun (s, d) -> group (doc_of_string s ^/^ equals ^/^ group d)) flds
in
braces (align flds_doc) | val pp_record (flds: list (string & document)) : Tac document
let pp_record (flds: list (string & document)) : Tac document = | true | null | false | let flds_doc =
separate_map (doc_of_string ";")
(fun (s, d) -> group (doc_of_string s ^/^ equals ^/^ group d))
flds
in
braces (align flds_doc) | {
"checked_file": "Pulse.PP.fst.checked",
"dependencies": [
"Pulse.Typing.Env.fsti.checked",
"Pulse.Typing.fst.checked",
"Pulse.Syntax.Printer.fsti.checked",
"Pulse.Syntax.Base.fsti.checked",
"Pulse.Show.fst.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Stubs.Pprint.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.PP.fst"
} | [] | [
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.string",
"FStar.Stubs.Pprint.document",
"FStar.Stubs.Pprint.braces",
"FStar.Stubs.Pprint.align",
"Pulse.PP.separate_map",
"FStar.Stubs.Pprint.doc_of_string",
"FStar.Stubs.Pprint.group",
"FStar.Stubs.Pprint.op_Hat_Slash_Hat",
"FStar.Stubs.Pprint.equals"
] | [] | module Pulse.PP
include FStar.Stubs.Pprint
open FStar.Tactics
open FStar.Tactics.Typeclasses
open FStar.Stubs.Pprint
open Pulse.Typing
open Pulse.Syntax.Base
open Pulse.Syntax.Printer
open Pulse.Show
(* A helper to create wrapped text *)
val text : string -> FStar.Stubs.Pprint.document
let text (s:string) : FStar.Stubs.Pprint.document =
flow (break_ 1) (words s)
(* Nests a document 2 levels deep, as a block. It inserts a hardline
before the doc, so if you want to format something as
hdr
subdoc
tail
you should write hdr ^^ indent (subdoc) ^/^ tail. Note the ^^ vs ^/^.
*)
val indent : document -> document
let indent d =
nest 2 (hardline ^^ align d)
class printable (a:Type) = {
pp : a -> Tac document;
}
(* Repurposing a show instance *)
let from_show #a {| d : tac_showable a |} : printable a = {
pp = (fun x -> arbitrary_string (show x));
}
instance _ : printable string = from_show
instance _ : printable unit = from_show
instance _ : printable bool = from_show
instance _ : printable int = from_show
instance _ : printable ctag = from_show
instance printable_option (a:Type) (_ : printable a) : printable (option a) = {
pp = (function None -> doc_of_string "None"
| Some v -> doc_of_string "Some" ^/^ pp v);
}
// Cannot use Pprint.separate_map, it takes a pure func
private
let rec separate_map (sep: document) (f : 'a -> Tac document) (l : list 'a) : Tac document =
match l with
| [] -> empty
| [x] -> f x
| x::xs -> f x ^^ sep ^/^ separate_map sep f xs
instance showable_list (a:Type) (_ : printable a) : printable (list a) = {
pp = (fun l -> brackets (separate_map comma pp l))
}
instance _ : printable term = from_show
instance _ : printable universe = from_show
instance _ : printable comp = from_show
instance _ : printable env = {
pp = Pulse.Typing.Env.env_to_doc;
} | false | false | Pulse.PP.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pp_record (flds: list (string & document)) : Tac document | [] | Pulse.PP.pp_record | {
"file_name": "lib/steel/pulse/Pulse.PP.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | flds: Prims.list (Prims.string * FStar.Stubs.Pprint.document)
-> FStar.Tactics.Effect.Tac FStar.Stubs.Pprint.document | {
"end_col": 25,
"end_line": 77,
"start_col": 64,
"start_line": 73
} |
Prims.Tot | [@@ FStar.Tactics.Typeclasses.tcinstance]
val printable_fstar_term:printable Reflection.V2.term | [
{
"abbrev": false,
"full_module": "Pulse.Show",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Printer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Pprint",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Typeclasses",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Pprint",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | instance printable_fstar_term : printable Reflection.V2.term = {
pp = (fun t -> doc_of_string (Tactics.V2.term_to_string t))
} | [@@ FStar.Tactics.Typeclasses.tcinstance]
val printable_fstar_term:printable Reflection.V2.term
[@@ FStar.Tactics.Typeclasses.tcinstance]
let printable_fstar_term:printable Reflection.V2.term = | false | null | false | { pp = (fun t -> doc_of_string (Tactics.V2.term_to_string t)) } | {
"checked_file": "Pulse.PP.fst.checked",
"dependencies": [
"Pulse.Typing.Env.fsti.checked",
"Pulse.Typing.fst.checked",
"Pulse.Syntax.Printer.fsti.checked",
"Pulse.Syntax.Base.fsti.checked",
"Pulse.Show.fst.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Stubs.Pprint.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.PP.fst"
} | [
"total"
] | [
"Pulse.PP.Mkprintable",
"FStar.Reflection.Types.term",
"FStar.Stubs.Pprint.doc_of_string",
"FStar.Stubs.Pprint.document",
"Prims.string",
"FStar.Tactics.V2.Builtins.term_to_string"
] | [] | module Pulse.PP
include FStar.Stubs.Pprint
open FStar.Tactics
open FStar.Tactics.Typeclasses
open FStar.Stubs.Pprint
open Pulse.Typing
open Pulse.Syntax.Base
open Pulse.Syntax.Printer
open Pulse.Show
(* A helper to create wrapped text *)
val text : string -> FStar.Stubs.Pprint.document
let text (s:string) : FStar.Stubs.Pprint.document =
flow (break_ 1) (words s)
(* Nests a document 2 levels deep, as a block. It inserts a hardline
before the doc, so if you want to format something as
hdr
subdoc
tail
you should write hdr ^^ indent (subdoc) ^/^ tail. Note the ^^ vs ^/^.
*)
val indent : document -> document
let indent d =
nest 2 (hardline ^^ align d)
class printable (a:Type) = {
pp : a -> Tac document;
}
(* Repurposing a show instance *)
let from_show #a {| d : tac_showable a |} : printable a = {
pp = (fun x -> arbitrary_string (show x));
}
instance _ : printable string = from_show
instance _ : printable unit = from_show
instance _ : printable bool = from_show
instance _ : printable int = from_show
instance _ : printable ctag = from_show
instance printable_option (a:Type) (_ : printable a) : printable (option a) = {
pp = (function None -> doc_of_string "None"
| Some v -> doc_of_string "Some" ^/^ pp v);
}
// Cannot use Pprint.separate_map, it takes a pure func
private
let rec separate_map (sep: document) (f : 'a -> Tac document) (l : list 'a) : Tac document =
match l with
| [] -> empty
| [x] -> f x
| x::xs -> f x ^^ sep ^/^ separate_map sep f xs
instance showable_list (a:Type) (_ : printable a) : printable (list a) = {
pp = (fun l -> brackets (separate_map comma pp l))
}
instance _ : printable term = from_show
instance _ : printable universe = from_show
instance _ : printable comp = from_show
instance _ : printable env = {
pp = Pulse.Typing.Env.env_to_doc;
}
let pp_record (flds : list (string & document)) : Tac document =
let flds_doc =
separate_map (doc_of_string ";") (fun (s, d) -> group (doc_of_string s ^/^ equals ^/^ group d)) flds
in
braces (align flds_doc)
instance _ : printable post_hint_t = {
pp = (fun (h:post_hint_t) ->
pp_record [ "g", pp h.g
; "ctag_hint", pp h.ctag_hint
; "ret_ty", pp h.ret_ty
; "u", pp h.u
; "post", pp h.post ]);
}
// FIXME: use term_to_doc when available | false | true | Pulse.PP.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | [@@ FStar.Tactics.Typeclasses.tcinstance]
val printable_fstar_term:printable Reflection.V2.term | [] | Pulse.PP.printable_fstar_term | {
"file_name": "lib/steel/pulse/Pulse.PP.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | Pulse.PP.printable FStar.Reflection.Types.term | {
"end_col": 61,
"end_line": 90,
"start_col": 2,
"start_line": 90
} |
Prims.Tot | val text : string -> FStar.Stubs.Pprint.document | [
{
"abbrev": false,
"full_module": "Pulse.Show",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Printer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Pprint",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Typeclasses",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Pprint",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let text (s:string) : FStar.Stubs.Pprint.document =
flow (break_ 1) (words s) | val text : string -> FStar.Stubs.Pprint.document
let text (s: string) : FStar.Stubs.Pprint.document = | false | null | false | flow (break_ 1) (words s) | {
"checked_file": "Pulse.PP.fst.checked",
"dependencies": [
"Pulse.Typing.Env.fsti.checked",
"Pulse.Typing.fst.checked",
"Pulse.Syntax.Printer.fsti.checked",
"Pulse.Syntax.Base.fsti.checked",
"Pulse.Show.fst.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Stubs.Pprint.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.PP.fst"
} | [
"total"
] | [
"Prims.string",
"FStar.Stubs.Pprint.flow",
"FStar.Stubs.Pprint.break_",
"FStar.Stubs.Pprint.words",
"FStar.Stubs.Pprint.document"
] | [] | module Pulse.PP
include FStar.Stubs.Pprint
open FStar.Tactics
open FStar.Tactics.Typeclasses
open FStar.Stubs.Pprint
open Pulse.Typing
open Pulse.Syntax.Base
open Pulse.Syntax.Printer
open Pulse.Show
(* A helper to create wrapped text *)
val text : string -> FStar.Stubs.Pprint.document | false | true | Pulse.PP.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val text : string -> FStar.Stubs.Pprint.document | [] | Pulse.PP.text | {
"file_name": "lib/steel/pulse/Pulse.PP.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | s: Prims.string -> FStar.Stubs.Pprint.document | {
"end_col": 27,
"end_line": 17,
"start_col": 2,
"start_line": 17
} |
Prims.Tot | val from_show (#a: _) {| d: tac_showable a |} : printable a | [
{
"abbrev": false,
"full_module": "Pulse.Show",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Printer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Pprint",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Typeclasses",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Pprint",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let from_show #a {| d : tac_showable a |} : printable a = {
pp = (fun x -> arbitrary_string (show x));
} | val from_show (#a: _) {| d: tac_showable a |} : printable a
let from_show #a {| d: tac_showable a |} : printable a = | false | null | false | { pp = (fun x -> arbitrary_string (show x)) } | {
"checked_file": "Pulse.PP.fst.checked",
"dependencies": [
"Pulse.Typing.Env.fsti.checked",
"Pulse.Typing.fst.checked",
"Pulse.Syntax.Printer.fsti.checked",
"Pulse.Syntax.Base.fsti.checked",
"Pulse.Show.fst.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Stubs.Pprint.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.PP.fst"
} | [
"total"
] | [
"Pulse.Show.tac_showable",
"Pulse.PP.Mkprintable",
"FStar.Stubs.Pprint.arbitrary_string",
"FStar.Stubs.Pprint.document",
"Prims.string",
"Pulse.Show.show",
"Pulse.PP.printable"
] | [] | module Pulse.PP
include FStar.Stubs.Pprint
open FStar.Tactics
open FStar.Tactics.Typeclasses
open FStar.Stubs.Pprint
open Pulse.Typing
open Pulse.Syntax.Base
open Pulse.Syntax.Printer
open Pulse.Show
(* A helper to create wrapped text *)
val text : string -> FStar.Stubs.Pprint.document
let text (s:string) : FStar.Stubs.Pprint.document =
flow (break_ 1) (words s)
(* Nests a document 2 levels deep, as a block. It inserts a hardline
before the doc, so if you want to format something as
hdr
subdoc
tail
you should write hdr ^^ indent (subdoc) ^/^ tail. Note the ^^ vs ^/^.
*)
val indent : document -> document
let indent d =
nest 2 (hardline ^^ align d)
class printable (a:Type) = {
pp : a -> Tac document;
}
(* Repurposing a show instance *) | false | false | Pulse.PP.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val from_show (#a: _) {| d: tac_showable a |} : printable a | [] | Pulse.PP.from_show | {
"file_name": "lib/steel/pulse/Pulse.PP.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {| d: Pulse.Show.tac_showable a |} -> Pulse.PP.printable a | {
"end_col": 44,
"end_line": 38,
"start_col": 2,
"start_line": 38
} |
Prims.Tot | val indent : document -> document | [
{
"abbrev": false,
"full_module": "Pulse.Show",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Printer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Pprint",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Typeclasses",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Pprint",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let indent d =
nest 2 (hardline ^^ align d) | val indent : document -> document
let indent d = | false | null | false | nest 2 (hardline ^^ align d) | {
"checked_file": "Pulse.PP.fst.checked",
"dependencies": [
"Pulse.Typing.Env.fsti.checked",
"Pulse.Typing.fst.checked",
"Pulse.Syntax.Printer.fsti.checked",
"Pulse.Syntax.Base.fsti.checked",
"Pulse.Show.fst.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Stubs.Pprint.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.PP.fst"
} | [
"total"
] | [
"FStar.Stubs.Pprint.document",
"FStar.Stubs.Pprint.nest",
"FStar.Stubs.Pprint.op_Hat_Hat",
"FStar.Stubs.Pprint.hardline",
"FStar.Stubs.Pprint.align"
] | [] | module Pulse.PP
include FStar.Stubs.Pprint
open FStar.Tactics
open FStar.Tactics.Typeclasses
open FStar.Stubs.Pprint
open Pulse.Typing
open Pulse.Syntax.Base
open Pulse.Syntax.Printer
open Pulse.Show
(* A helper to create wrapped text *)
val text : string -> FStar.Stubs.Pprint.document
let text (s:string) : FStar.Stubs.Pprint.document =
flow (break_ 1) (words s)
(* Nests a document 2 levels deep, as a block. It inserts a hardline
before the doc, so if you want to format something as
hdr
subdoc
tail
you should write hdr ^^ indent (subdoc) ^/^ tail. Note the ^^ vs ^/^.
*)
val indent : document -> document | false | true | Pulse.PP.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val indent : document -> document | [] | Pulse.PP.indent | {
"file_name": "lib/steel/pulse/Pulse.PP.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | d: FStar.Stubs.Pprint.document -> FStar.Stubs.Pprint.document | {
"end_col": 30,
"end_line": 30,
"start_col": 2,
"start_line": 30
} |
Prims.Tot | [@@ FStar.Tactics.Typeclasses.tcinstance]
val showable_list: a: Type -> printable a -> printable (list a) | [
{
"abbrev": false,
"full_module": "Pulse.Show",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Printer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Pprint",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Typeclasses",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Pprint",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | instance showable_list (a:Type) (_ : printable a) : printable (list a) = {
pp = (fun l -> brackets (separate_map comma pp l))
} | [@@ FStar.Tactics.Typeclasses.tcinstance]
val showable_list: a: Type -> printable a -> printable (list a)
[@@ FStar.Tactics.Typeclasses.tcinstance]
let showable_list (a: Type) (_: printable a) : printable (list a) = | false | null | false | { pp = (fun l -> brackets (separate_map comma pp l)) } | {
"checked_file": "Pulse.PP.fst.checked",
"dependencies": [
"Pulse.Typing.Env.fsti.checked",
"Pulse.Typing.fst.checked",
"Pulse.Syntax.Printer.fsti.checked",
"Pulse.Syntax.Base.fsti.checked",
"Pulse.Show.fst.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Stubs.Pprint.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.PP.fst"
} | [
"total"
] | [
"Pulse.PP.printable",
"Pulse.PP.Mkprintable",
"Prims.list",
"FStar.Stubs.Pprint.brackets",
"FStar.Stubs.Pprint.document",
"Pulse.PP.separate_map",
"FStar.Stubs.Pprint.comma",
"Pulse.PP.pp"
] | [] | module Pulse.PP
include FStar.Stubs.Pprint
open FStar.Tactics
open FStar.Tactics.Typeclasses
open FStar.Stubs.Pprint
open Pulse.Typing
open Pulse.Syntax.Base
open Pulse.Syntax.Printer
open Pulse.Show
(* A helper to create wrapped text *)
val text : string -> FStar.Stubs.Pprint.document
let text (s:string) : FStar.Stubs.Pprint.document =
flow (break_ 1) (words s)
(* Nests a document 2 levels deep, as a block. It inserts a hardline
before the doc, so if you want to format something as
hdr
subdoc
tail
you should write hdr ^^ indent (subdoc) ^/^ tail. Note the ^^ vs ^/^.
*)
val indent : document -> document
let indent d =
nest 2 (hardline ^^ align d)
class printable (a:Type) = {
pp : a -> Tac document;
}
(* Repurposing a show instance *)
let from_show #a {| d : tac_showable a |} : printable a = {
pp = (fun x -> arbitrary_string (show x));
}
instance _ : printable string = from_show
instance _ : printable unit = from_show
instance _ : printable bool = from_show
instance _ : printable int = from_show
instance _ : printable ctag = from_show
instance printable_option (a:Type) (_ : printable a) : printable (option a) = {
pp = (function None -> doc_of_string "None"
| Some v -> doc_of_string "Some" ^/^ pp v);
}
// Cannot use Pprint.separate_map, it takes a pure func
private
let rec separate_map (sep: document) (f : 'a -> Tac document) (l : list 'a) : Tac document =
match l with
| [] -> empty
| [x] -> f x
| x::xs -> f x ^^ sep ^/^ separate_map sep f xs | false | false | Pulse.PP.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | [@@ FStar.Tactics.Typeclasses.tcinstance]
val showable_list: a: Type -> printable a -> printable (list a) | [] | Pulse.PP.showable_list | {
"file_name": "lib/steel/pulse/Pulse.PP.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | a: Type -> _: Pulse.PP.printable a -> Pulse.PP.printable (Prims.list a) | {
"end_col": 52,
"end_line": 62,
"start_col": 2,
"start_line": 62
} |
FStar.Tactics.Effect.Tac | val separate_map (sep: document) (f: ('a -> Tac document)) (l: list 'a) : Tac document | [
{
"abbrev": false,
"full_module": "Pulse.Show",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Printer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Pprint",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Typeclasses",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Pprint",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec separate_map (sep: document) (f : 'a -> Tac document) (l : list 'a) : Tac document =
match l with
| [] -> empty
| [x] -> f x
| x::xs -> f x ^^ sep ^/^ separate_map sep f xs | val separate_map (sep: document) (f: ('a -> Tac document)) (l: list 'a) : Tac document
let rec separate_map (sep: document) (f: ('a -> Tac document)) (l: list 'a) : Tac document = | true | null | false | match l with
| [] -> empty
| [x] -> f x
| x :: xs -> f x ^^ sep ^/^ separate_map sep f xs | {
"checked_file": "Pulse.PP.fst.checked",
"dependencies": [
"Pulse.Typing.Env.fsti.checked",
"Pulse.Typing.fst.checked",
"Pulse.Syntax.Printer.fsti.checked",
"Pulse.Syntax.Base.fsti.checked",
"Pulse.Show.fst.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Stubs.Pprint.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.PP.fst"
} | [] | [
"FStar.Stubs.Pprint.document",
"Prims.list",
"FStar.Stubs.Pprint.empty",
"FStar.Stubs.Pprint.op_Hat_Hat",
"FStar.Stubs.Pprint.op_Hat_Slash_Hat",
"Pulse.PP.separate_map"
] | [] | module Pulse.PP
include FStar.Stubs.Pprint
open FStar.Tactics
open FStar.Tactics.Typeclasses
open FStar.Stubs.Pprint
open Pulse.Typing
open Pulse.Syntax.Base
open Pulse.Syntax.Printer
open Pulse.Show
(* A helper to create wrapped text *)
val text : string -> FStar.Stubs.Pprint.document
let text (s:string) : FStar.Stubs.Pprint.document =
flow (break_ 1) (words s)
(* Nests a document 2 levels deep, as a block. It inserts a hardline
before the doc, so if you want to format something as
hdr
subdoc
tail
you should write hdr ^^ indent (subdoc) ^/^ tail. Note the ^^ vs ^/^.
*)
val indent : document -> document
let indent d =
nest 2 (hardline ^^ align d)
class printable (a:Type) = {
pp : a -> Tac document;
}
(* Repurposing a show instance *)
let from_show #a {| d : tac_showable a |} : printable a = {
pp = (fun x -> arbitrary_string (show x));
}
instance _ : printable string = from_show
instance _ : printable unit = from_show
instance _ : printable bool = from_show
instance _ : printable int = from_show
instance _ : printable ctag = from_show
instance printable_option (a:Type) (_ : printable a) : printable (option a) = {
pp = (function None -> doc_of_string "None"
| Some v -> doc_of_string "Some" ^/^ pp v);
}
// Cannot use Pprint.separate_map, it takes a pure func
private | false | false | Pulse.PP.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val separate_map (sep: document) (f: ('a -> Tac document)) (l: list 'a) : Tac document | [
"recursion"
] | Pulse.PP.separate_map | {
"file_name": "lib/steel/pulse/Pulse.PP.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
sep: FStar.Stubs.Pprint.document ->
f: (_: 'a -> FStar.Tactics.Effect.Tac FStar.Stubs.Pprint.document) ->
l: Prims.list 'a
-> FStar.Tactics.Effect.Tac FStar.Stubs.Pprint.document | {
"end_col": 49,
"end_line": 59,
"start_col": 2,
"start_line": 56
} |
Prims.Tot | [@@ FStar.Tactics.Typeclasses.tcinstance]
val printable_option: a: Type -> printable a -> printable (option a) | [
{
"abbrev": false,
"full_module": "Pulse.Show",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Printer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Pprint",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Typeclasses",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Pprint",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | instance printable_option (a:Type) (_ : printable a) : printable (option a) = {
pp = (function None -> doc_of_string "None"
| Some v -> doc_of_string "Some" ^/^ pp v);
} | [@@ FStar.Tactics.Typeclasses.tcinstance]
val printable_option: a: Type -> printable a -> printable (option a)
[@@ FStar.Tactics.Typeclasses.tcinstance]
let printable_option (a: Type) (_: printable a) : printable (option a) = | false | null | false | {
pp
=
(function
| None -> doc_of_string "None"
| Some v -> doc_of_string "Some" ^/^ pp v)
} | {
"checked_file": "Pulse.PP.fst.checked",
"dependencies": [
"Pulse.Typing.Env.fsti.checked",
"Pulse.Typing.fst.checked",
"Pulse.Syntax.Printer.fsti.checked",
"Pulse.Syntax.Base.fsti.checked",
"Pulse.Show.fst.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Stubs.Pprint.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.PP.fst"
} | [
"total"
] | [
"Pulse.PP.printable",
"Pulse.PP.Mkprintable",
"FStar.Pervasives.Native.option",
"FStar.Stubs.Pprint.doc_of_string",
"FStar.Stubs.Pprint.document",
"FStar.Stubs.Pprint.op_Hat_Slash_Hat",
"Pulse.PP.pp"
] | [] | module Pulse.PP
include FStar.Stubs.Pprint
open FStar.Tactics
open FStar.Tactics.Typeclasses
open FStar.Stubs.Pprint
open Pulse.Typing
open Pulse.Syntax.Base
open Pulse.Syntax.Printer
open Pulse.Show
(* A helper to create wrapped text *)
val text : string -> FStar.Stubs.Pprint.document
let text (s:string) : FStar.Stubs.Pprint.document =
flow (break_ 1) (words s)
(* Nests a document 2 levels deep, as a block. It inserts a hardline
before the doc, so if you want to format something as
hdr
subdoc
tail
you should write hdr ^^ indent (subdoc) ^/^ tail. Note the ^^ vs ^/^.
*)
val indent : document -> document
let indent d =
nest 2 (hardline ^^ align d)
class printable (a:Type) = {
pp : a -> Tac document;
}
(* Repurposing a show instance *)
let from_show #a {| d : tac_showable a |} : printable a = {
pp = (fun x -> arbitrary_string (show x));
}
instance _ : printable string = from_show
instance _ : printable unit = from_show
instance _ : printable bool = from_show
instance _ : printable int = from_show
instance _ : printable ctag = from_show | false | false | Pulse.PP.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | [@@ FStar.Tactics.Typeclasses.tcinstance]
val printable_option: a: Type -> printable a -> printable (option a) | [] | Pulse.PP.printable_option | {
"file_name": "lib/steel/pulse/Pulse.PP.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | a: Type -> _: Pulse.PP.printable a -> Pulse.PP.printable (FStar.Pervasives.Native.option a) | {
"end_col": 60,
"end_line": 50,
"start_col": 2,
"start_line": 49
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let print_explicit_register_arg (n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (reserved:reg_64 -> bool) (names:nat -> string) =
let ty = match a with
| TD_Base _ -> "uint64_t "
| _ -> "uint64_t *"
in
if reserved (of_arg i) then
// If the associated register is reserved, we really this argument in it. For instance if it is Rdx and we have Mul(x) instructions
true, " register " ^ ty ^ names i ^ "_r __asm__(\"" ^ P.print_reg_name (of_arg i) ^ "\") = " ^ names i ^ ";\n"
else false, "" | let print_explicit_register_arg
(n: nat)
(a: td)
(i: nat{i < n})
(of_arg: (reg_nat n -> reg_64))
(reserved: (reg_64 -> bool))
(names: (nat -> string))
= | false | null | false | let ty =
match a with
| TD_Base _ -> "uint64_t "
| _ -> "uint64_t *"
in
if reserved (of_arg i)
then
true,
" register " ^
ty ^ names i ^ "_r __asm__(\"" ^ P.print_reg_name (of_arg i) ^ "\") = " ^ names i ^ ";\n"
else false, "" | {
"checked_file": "Vale.X64.Print_Inline_s.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Print_Inline_s.fst"
} | [
"total"
] | [
"Prims.nat",
"Vale.Interop.Base.td",
"Prims.b2t",
"Prims.op_LessThan",
"Vale.Interop.X64.reg_nat",
"Vale.X64.Machine_s.reg_64",
"Prims.bool",
"Prims.string",
"FStar.Pervasives.Native.Mktuple2",
"Prims.op_Hat",
"Vale.X64.Print_s.print_reg_name",
"FStar.Pervasives.Native.tuple2",
"Vale.Interop.Base.valid_base_type"
] | [] | module Vale.X64.Print_Inline_s
open FStar.Mul
open FStar.List.Tot
open Vale.X64.Machine_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Instruction_s
open FStar.IO
open Vale.Interop.Base
open Vale.Interop.X64
module P = Vale.X64.Print_s
let print_rettype (ret_val:option string) = match ret_val with
| None -> "void"
| Some _ -> "uint64_t"
let print_basetype (t:base_typ) = match t with
| TUInt8 -> "uint8_t"
| TUInt16 -> "uint16_t"
| TUInt32 -> "uint32_t"
| TUInt64 -> "uint64_t"
| TUInt128 -> "ERROR"
// Returns "uint8_t arg2" or "uint64_t* arg0" for instance
let print_arg (a:td) (i:nat) (names:nat -> string) = match a with
| TD_Base src -> print_basetype src ^ " " ^ names i
| TD_Buffer src _ _ | TD_ImmBuffer src _ _ -> print_basetype src ^ " *" ^ names i
// Prints a list of args with their types, separated by a comma
let rec print_args (args:list td) (i:nat) (names:nat -> string) = match args with
| [] -> ""
| [a] -> print_arg a i names
| a::q -> print_arg a i names ^ ", " ^ print_args q (i+1) names
let rec build_reserved_args_outs (l:list instr_out) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let (_, op) = hd in
let reserved : (reg_64 -> bool) = (fun r ->
match op with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_outs tl reserved r
let rec build_reserved_args_ins (l:list instr_operand) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let reserved : (reg_64 -> bool) = (fun r ->
match hd with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_ins tl reserved r
// Traverses code, looking for instructions implicitly using registers.
// When found, mark such registers as reserved so that they are not used during implicit allocation
let rec build_reserved_args (c:code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases c) =
fun r ->
(match c with
| Ins ins -> begin
match ins with
| Instr i _ _ ->
let reserved = build_reserved_args_outs i.outs reserved in
let reserved = build_reserved_args_ins (InstrTypeRecord?.args i) reserved in
reserved r
| _ -> reserved r
end
| Block l -> (build_reserved_args_block l reserved) r
| IfElse cond ifTrue ifFalse ->
let reservedT = build_reserved_args ifTrue reserved in
build_reserved_args ifFalse reservedT r
| While cond body -> build_reserved_args body reserved r
)
and build_reserved_args_block (l:list code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r -> (
match l with
| [] -> reserved r
| hd::tl ->
let reserved = build_reserved_args hd reserved in
build_reserved_args_block tl reserved r
)
// Prints `"=&r" (name)` if an output is specified
let print_output_ret ret_val (reg_names:reg_64 -> string) (counter:nat) : list string & (reg_64 -> string) & nat
= match ret_val with
| None -> [], reg_names, counter
| Some name -> (["\"=&r\" (" ^ name ^ ")"],
// If r = rax then address it as current arg number
(fun r -> if r = 0 then string_of_int counter else reg_names r),
counter + 1)
// If the register in which a is passed is modified, we should specify `"+&r" (name)`
let print_modified_input
(n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then
(["\"+&r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1
) else ([], reg_names, counter)
// Get a list of strings corresponding to modified inputs
let rec get_modified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{i + List.Tot.length args <= n}) (ret_val:option string)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat
= match args with
| [] -> print_output_ret ret_val reg_names counter
| a::q ->
let output, reg_names, counter = print_modified_input n a i of_arg regs_mod reserved_regs reg_names counter arg_names in
let outputs, reg_names, counter = get_modified_input_strings n of_arg regs_mod reserved_regs q (i+1) ret_val reg_names counter arg_names in
output @ outputs, reg_names, counter
// Print the list of modified inputs, separated by commas
let print_modified_inputs
(n:nat)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n})
(ret_val:option string)
(reg_names:reg_64 -> string)
(counter:nat)
(arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let outputs, output_reg_names, output_nbr = get_modified_input_strings n of_arg regs_mod reserved_regs args 0 ret_val reg_names counter arg_names in
aux outputs, output_reg_names, output_nbr
// If the register in which an arg is passed is not modified, we should specify it as `"r" (name)`
let print_nonmodified_input
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(a:td) (i:nat{i < n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then ([], reg_names, counter) else
(["\"r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1)
// Get a list of strings corresponding to modified inputs
let rec get_nonmodified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{List.Tot.length args + i <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string)
= match args with
| [] -> [], reg_names, counter
| a::q ->
let input, reg_names, counter = print_nonmodified_input n of_arg regs_mod reserved_regs a i reg_names counter arg_names in
let inputs, reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs q (i+1) reg_names counter arg_names in
input @ inputs, reg_names, counter
let print_nonmodified_inputs
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let inputs, input_reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs args 0 reg_names counter arg_names in
aux inputs, input_reg_names, counter
// Print the list of modified registers, + memory and cc
let print_modified_registers
(n:nat)
(ret_val:option string)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_args:reg_64 -> bool)
(args:list td) =
// This register was already specified as output
let output_register a = Some? ret_val && a = rRax in
let rec input_register (i:nat) (a:reg_64) : Tot bool (decreases (n-i)) =
if i >= n then false
else
a = of_arg i // This register was already specified for the i-th argument
|| input_register (i+1) a
in
let rec aux = function
| [] -> "\"memory\", \"cc\"\n"
| a::q ->
// This register is not modified, or was already specified as input or output: we skip it
if not (regs_mod a) || input_register 0 a || output_register a then aux q
// Register not modified or already specified in inputs, we add it
else "\"%" ^ P.print_reg_name a ^ "\", " ^ aux q
in aux [rRax; rRbx; rRcx; rRdx; rRsi; rRdi; rRbp; rRsp; rR8; rR9; rR10; rR11; rR12; rR13; rR14; rR15] | false | false | Vale.X64.Print_Inline_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val print_explicit_register_arg : n: Prims.nat ->
a: Vale.Interop.Base.td ->
i: Prims.nat{i < n} ->
of_arg: (_: Vale.Interop.X64.reg_nat n -> Vale.X64.Machine_s.reg_64) ->
reserved: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
names: (_: Prims.nat -> Prims.string)
-> Prims.bool * Prims.string | [] | Vale.X64.Print_Inline_s.print_explicit_register_arg | {
"file_name": "vale/specs/hardware/Vale.X64.Print_Inline_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
n: Prims.nat ->
a: Vale.Interop.Base.td ->
i: Prims.nat{i < n} ->
of_arg: (_: Vale.Interop.X64.reg_nat n -> Vale.X64.Machine_s.reg_64) ->
reserved: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
names: (_: Prims.nat -> Prims.string)
-> Prims.bool * Prims.string | {
"end_col": 16,
"end_line": 215,
"start_col": 140,
"start_line": 207
} |
|
Prims.Tot | val print_ins (ins: ins) (p: P.printer) : string | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let print_ins (ins:ins) (p:P.printer) : string =
match ins with
| Instr _ _ (AnnotateComment s) -> " // " ^ s
| Instr _ _ (AnnotateLargeComment s) -> "\n /////// " ^ s ^ " ////// \n"
| Instr _ _ (AnnotateSpace n) -> print_spaces n
| _ -> " \"" ^ P.print_ins ins p ^ ";\"" | val print_ins (ins: ins) (p: P.printer) : string
let print_ins (ins: ins) (p: P.printer) : string = | false | null | false | match ins with
| Instr _ _ (AnnotateComment s) -> " // " ^ s
| Instr _ _ (AnnotateLargeComment s) -> "\n /////// " ^ s ^ " ////// \n"
| Instr _ _ (AnnotateSpace n) -> print_spaces n
| _ -> " \"" ^ P.print_ins ins p ^ ";\"" | {
"checked_file": "Vale.X64.Print_Inline_s.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Print_Inline_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_Semantics_s.ins",
"Vale.X64.Print_s.printer",
"Vale.X64.Instruction_s.instr_t_record",
"Vale.X64.Instruction_s.instr_operands_t",
"Vale.X64.Instruction_s.__proj__InstrTypeRecord__item__outs",
"Vale.X64.Instruction_s.__proj__InstrTypeRecord__item__args",
"Prims.string",
"Prims.eq2",
"Vale.X64.Instruction_s.InstrTypeRecord",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Comment",
"Prims.op_Hat",
"Vale.X64.Instructions_s.ins_LargeComment",
"Prims.nat",
"Vale.X64.Instructions_s.ins_Space",
"Vale.X64.Print_Inline_s.print_spaces",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.X64.Print_s.print_ins"
] | [] | module Vale.X64.Print_Inline_s
open FStar.Mul
open FStar.List.Tot
open Vale.X64.Machine_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Instruction_s
open FStar.IO
open Vale.Interop.Base
open Vale.Interop.X64
module P = Vale.X64.Print_s
let print_rettype (ret_val:option string) = match ret_val with
| None -> "void"
| Some _ -> "uint64_t"
let print_basetype (t:base_typ) = match t with
| TUInt8 -> "uint8_t"
| TUInt16 -> "uint16_t"
| TUInt32 -> "uint32_t"
| TUInt64 -> "uint64_t"
| TUInt128 -> "ERROR"
// Returns "uint8_t arg2" or "uint64_t* arg0" for instance
let print_arg (a:td) (i:nat) (names:nat -> string) = match a with
| TD_Base src -> print_basetype src ^ " " ^ names i
| TD_Buffer src _ _ | TD_ImmBuffer src _ _ -> print_basetype src ^ " *" ^ names i
// Prints a list of args with their types, separated by a comma
let rec print_args (args:list td) (i:nat) (names:nat -> string) = match args with
| [] -> ""
| [a] -> print_arg a i names
| a::q -> print_arg a i names ^ ", " ^ print_args q (i+1) names
let rec build_reserved_args_outs (l:list instr_out) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let (_, op) = hd in
let reserved : (reg_64 -> bool) = (fun r ->
match op with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_outs tl reserved r
let rec build_reserved_args_ins (l:list instr_operand) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let reserved : (reg_64 -> bool) = (fun r ->
match hd with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_ins tl reserved r
// Traverses code, looking for instructions implicitly using registers.
// When found, mark such registers as reserved so that they are not used during implicit allocation
let rec build_reserved_args (c:code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases c) =
fun r ->
(match c with
| Ins ins -> begin
match ins with
| Instr i _ _ ->
let reserved = build_reserved_args_outs i.outs reserved in
let reserved = build_reserved_args_ins (InstrTypeRecord?.args i) reserved in
reserved r
| _ -> reserved r
end
| Block l -> (build_reserved_args_block l reserved) r
| IfElse cond ifTrue ifFalse ->
let reservedT = build_reserved_args ifTrue reserved in
build_reserved_args ifFalse reservedT r
| While cond body -> build_reserved_args body reserved r
)
and build_reserved_args_block (l:list code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r -> (
match l with
| [] -> reserved r
| hd::tl ->
let reserved = build_reserved_args hd reserved in
build_reserved_args_block tl reserved r
)
// Prints `"=&r" (name)` if an output is specified
let print_output_ret ret_val (reg_names:reg_64 -> string) (counter:nat) : list string & (reg_64 -> string) & nat
= match ret_val with
| None -> [], reg_names, counter
| Some name -> (["\"=&r\" (" ^ name ^ ")"],
// If r = rax then address it as current arg number
(fun r -> if r = 0 then string_of_int counter else reg_names r),
counter + 1)
// If the register in which a is passed is modified, we should specify `"+&r" (name)`
let print_modified_input
(n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then
(["\"+&r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1
) else ([], reg_names, counter)
// Get a list of strings corresponding to modified inputs
let rec get_modified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{i + List.Tot.length args <= n}) (ret_val:option string)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat
= match args with
| [] -> print_output_ret ret_val reg_names counter
| a::q ->
let output, reg_names, counter = print_modified_input n a i of_arg regs_mod reserved_regs reg_names counter arg_names in
let outputs, reg_names, counter = get_modified_input_strings n of_arg regs_mod reserved_regs q (i+1) ret_val reg_names counter arg_names in
output @ outputs, reg_names, counter
// Print the list of modified inputs, separated by commas
let print_modified_inputs
(n:nat)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n})
(ret_val:option string)
(reg_names:reg_64 -> string)
(counter:nat)
(arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let outputs, output_reg_names, output_nbr = get_modified_input_strings n of_arg regs_mod reserved_regs args 0 ret_val reg_names counter arg_names in
aux outputs, output_reg_names, output_nbr
// If the register in which an arg is passed is not modified, we should specify it as `"r" (name)`
let print_nonmodified_input
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(a:td) (i:nat{i < n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then ([], reg_names, counter) else
(["\"r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1)
// Get a list of strings corresponding to modified inputs
let rec get_nonmodified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{List.Tot.length args + i <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string)
= match args with
| [] -> [], reg_names, counter
| a::q ->
let input, reg_names, counter = print_nonmodified_input n of_arg regs_mod reserved_regs a i reg_names counter arg_names in
let inputs, reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs q (i+1) reg_names counter arg_names in
input @ inputs, reg_names, counter
let print_nonmodified_inputs
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let inputs, input_reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs args 0 reg_names counter arg_names in
aux inputs, input_reg_names, counter
// Print the list of modified registers, + memory and cc
let print_modified_registers
(n:nat)
(ret_val:option string)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_args:reg_64 -> bool)
(args:list td) =
// This register was already specified as output
let output_register a = Some? ret_val && a = rRax in
let rec input_register (i:nat) (a:reg_64) : Tot bool (decreases (n-i)) =
if i >= n then false
else
a = of_arg i // This register was already specified for the i-th argument
|| input_register (i+1) a
in
let rec aux = function
| [] -> "\"memory\", \"cc\"\n"
| a::q ->
// This register is not modified, or was already specified as input or output: we skip it
if not (regs_mod a) || input_register 0 a || output_register a then aux q
// Register not modified or already specified in inputs, we add it
else "\"%" ^ P.print_reg_name a ^ "\", " ^ aux q
in aux [rRax; rRbx; rRcx; rRdx; rRsi; rRdi; rRbp; rRsp; rR8; rR9; rR10; rR11; rR12; rR13; rR14; rR15]
// Prints "register uint64_t *argi_r __asm__("[reg]") = argi;\n"
let print_explicit_register_arg (n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (reserved:reg_64 -> bool) (names:nat -> string) =
let ty = match a with
| TD_Base _ -> "uint64_t "
| _ -> "uint64_t *"
in
if reserved (of_arg i) then
// If the associated register is reserved, we really this argument in it. For instance if it is Rdx and we have Mul(x) instructions
true, " register " ^ ty ^ names i ^ "_r __asm__(\"" ^ P.print_reg_name (of_arg i) ^ "\") = " ^ names i ^ ";\n"
else false, ""
let rec print_explicit_register_args (n:nat) (args:list td) (i:nat{i + List.length args = n}) (of_arg:reg_nat n -> reg_64) (reserved:reg_64 -> bool) (names:nat -> string) =
match args with
| [] -> false, ""
| a::q ->
let was_explicit, explicit_str = print_explicit_register_arg n a i of_arg reserved names in
let are_explicit, rest_str = print_explicit_register_args n q (i+1) of_arg reserved names in
was_explicit || are_explicit, explicit_str ^ rest_str
// If we have a return parameter with a reserved register, print "register uint64_t [name] __asm__("rax");\n"
let print_register_ret (reserved:reg_64 -> bool) = function
| None -> ""
| Some name -> if reserved rRax then " register uint64_t " ^ name ^ " __asm__(\"rax\");\n" else " uint64_t " ^ name ^ ";\n"
(* This is a copy from X64.Print_s, and should remain in sync. The difference is that
each line should be in quotes, and end by a semicolon in inline assembly *)
let print_cmp (c:ocmp) (counter:int) (p:P.printer) : string =
let print_ops (o1:operand64) (o2:operand64) : string =
let first, second = p.P.op_order (P.print_operand o1 p) (P.print_operand o2 p) in
" cmp " ^ first ^ ", " ^ second ^ "\n"
in
match c with
| OEq o1 o2 -> " \"" ^ print_ops o1 o2 ^ " je " ^ "L" ^ string_of_int counter ^ ";\"\n"
| ONe o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jne "^ "L" ^ string_of_int counter ^ ";\"\n"
| OLe o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jbe "^ "L" ^ string_of_int counter ^ ";\"\n"
| OGe o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jae "^ "L" ^ string_of_int counter ^ ";\"\n"
| OLt o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jb " ^ "L" ^ string_of_int counter ^ ";\"\n"
| OGt o1 o2 -> " \"" ^ print_ops o1 o2 ^ " ja " ^ "L" ^ string_of_int counter ^ ";\"\n"
let rec print_spaces (n:nat) : string =
match n with
| 0 -> ""
| n -> " " ^ print_spaces (n-1)
(* Overriding printer for formatting instructions *) | false | true | Vale.X64.Print_Inline_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val print_ins (ins: ins) (p: P.printer) : string | [] | Vale.X64.Print_Inline_s.print_ins | {
"file_name": "vale/specs/hardware/Vale.X64.Print_Inline_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | ins: Vale.X64.Machine_Semantics_s.ins -> p: Vale.X64.Print_s.printer -> Prims.string | {
"end_col": 45,
"end_line": 256,
"start_col": 2,
"start_line": 252
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let print_rettype (ret_val:option string) = match ret_val with
| None -> "void"
| Some _ -> "uint64_t" | let print_rettype (ret_val: option string) = | false | null | false | match ret_val with
| None -> "void"
| Some _ -> "uint64_t" | {
"checked_file": "Vale.X64.Print_Inline_s.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Print_Inline_s.fst"
} | [
"total"
] | [
"FStar.Pervasives.Native.option",
"Prims.string"
] | [] | module Vale.X64.Print_Inline_s
open FStar.Mul
open FStar.List.Tot
open Vale.X64.Machine_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Instruction_s
open FStar.IO
open Vale.Interop.Base
open Vale.Interop.X64
module P = Vale.X64.Print_s | false | true | Vale.X64.Print_Inline_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val print_rettype : ret_val: FStar.Pervasives.Native.option Prims.string -> Prims.string | [] | Vale.X64.Print_Inline_s.print_rettype | {
"file_name": "vale/specs/hardware/Vale.X64.Print_Inline_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | ret_val: FStar.Pervasives.Native.option Prims.string -> Prims.string | {
"end_col": 24,
"end_line": 16,
"start_col": 44,
"start_line": 14
} |
|
Prims.Tot | val print_modified_input
(n: nat)
(a: td)
(i: nat{i < n})
(of_arg: (reg_nat n -> reg_64))
(regs_mod reserved_regs: (reg_64 -> bool))
(reg_names: (reg_64 -> string))
(counter: nat)
(arg_names: (nat -> string))
: list string & (reg_64 -> string) & nat | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let print_modified_input
(n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then
(["\"+&r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1
) else ([], reg_names, counter) | val print_modified_input
(n: nat)
(a: td)
(i: nat{i < n})
(of_arg: (reg_nat n -> reg_64))
(regs_mod reserved_regs: (reg_64 -> bool))
(reg_names: (reg_64 -> string))
(counter: nat)
(arg_names: (nat -> string))
: list string & (reg_64 -> string) & nat
let print_modified_input
(n: nat)
(a: td)
(i: nat{i < n})
(of_arg: (reg_nat n -> reg_64))
(regs_mod reserved_regs: (reg_64 -> bool))
(reg_names: (reg_64 -> string))
(counter: nat)
(arg_names: (nat -> string))
: list string & (reg_64 -> string) & nat = | false | null | false | if regs_mod (of_arg i)
then
(["\"+&r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1)
else ([], reg_names, counter) | {
"checked_file": "Vale.X64.Print_Inline_s.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Print_Inline_s.fst"
} | [
"total"
] | [
"Prims.nat",
"Vale.Interop.Base.td",
"Prims.b2t",
"Prims.op_LessThan",
"Vale.Interop.X64.reg_nat",
"Vale.X64.Machine_s.reg_64",
"Prims.bool",
"Prims.string",
"FStar.Pervasives.Native.Mktuple3",
"Prims.list",
"Prims.Cons",
"Prims.op_Hat",
"Prims.Nil",
"Prims.op_AmpAmp",
"Prims.op_Equality",
"Prims.op_Negation",
"Prims.string_of_int",
"Prims.op_Addition",
"FStar.Pervasives.Native.tuple3"
] | [] | module Vale.X64.Print_Inline_s
open FStar.Mul
open FStar.List.Tot
open Vale.X64.Machine_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Instruction_s
open FStar.IO
open Vale.Interop.Base
open Vale.Interop.X64
module P = Vale.X64.Print_s
let print_rettype (ret_val:option string) = match ret_val with
| None -> "void"
| Some _ -> "uint64_t"
let print_basetype (t:base_typ) = match t with
| TUInt8 -> "uint8_t"
| TUInt16 -> "uint16_t"
| TUInt32 -> "uint32_t"
| TUInt64 -> "uint64_t"
| TUInt128 -> "ERROR"
// Returns "uint8_t arg2" or "uint64_t* arg0" for instance
let print_arg (a:td) (i:nat) (names:nat -> string) = match a with
| TD_Base src -> print_basetype src ^ " " ^ names i
| TD_Buffer src _ _ | TD_ImmBuffer src _ _ -> print_basetype src ^ " *" ^ names i
// Prints a list of args with their types, separated by a comma
let rec print_args (args:list td) (i:nat) (names:nat -> string) = match args with
| [] -> ""
| [a] -> print_arg a i names
| a::q -> print_arg a i names ^ ", " ^ print_args q (i+1) names
let rec build_reserved_args_outs (l:list instr_out) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let (_, op) = hd in
let reserved : (reg_64 -> bool) = (fun r ->
match op with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_outs tl reserved r
let rec build_reserved_args_ins (l:list instr_operand) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let reserved : (reg_64 -> bool) = (fun r ->
match hd with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_ins tl reserved r
// Traverses code, looking for instructions implicitly using registers.
// When found, mark such registers as reserved so that they are not used during implicit allocation
let rec build_reserved_args (c:code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases c) =
fun r ->
(match c with
| Ins ins -> begin
match ins with
| Instr i _ _ ->
let reserved = build_reserved_args_outs i.outs reserved in
let reserved = build_reserved_args_ins (InstrTypeRecord?.args i) reserved in
reserved r
| _ -> reserved r
end
| Block l -> (build_reserved_args_block l reserved) r
| IfElse cond ifTrue ifFalse ->
let reservedT = build_reserved_args ifTrue reserved in
build_reserved_args ifFalse reservedT r
| While cond body -> build_reserved_args body reserved r
)
and build_reserved_args_block (l:list code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r -> (
match l with
| [] -> reserved r
| hd::tl ->
let reserved = build_reserved_args hd reserved in
build_reserved_args_block tl reserved r
)
// Prints `"=&r" (name)` if an output is specified
let print_output_ret ret_val (reg_names:reg_64 -> string) (counter:nat) : list string & (reg_64 -> string) & nat
= match ret_val with
| None -> [], reg_names, counter
| Some name -> (["\"=&r\" (" ^ name ^ ")"],
// If r = rax then address it as current arg number
(fun r -> if r = 0 then string_of_int counter else reg_names r),
counter + 1)
// If the register in which a is passed is modified, we should specify `"+&r" (name)`
let print_modified_input
(n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool) | false | false | Vale.X64.Print_Inline_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val print_modified_input
(n: nat)
(a: td)
(i: nat{i < n})
(of_arg: (reg_nat n -> reg_64))
(regs_mod reserved_regs: (reg_64 -> bool))
(reg_names: (reg_64 -> string))
(counter: nat)
(arg_names: (nat -> string))
: list string & (reg_64 -> string) & nat | [] | Vale.X64.Print_Inline_s.print_modified_input | {
"file_name": "vale/specs/hardware/Vale.X64.Print_Inline_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
n: Prims.nat ->
a: Vale.Interop.Base.td ->
i: Prims.nat{i < n} ->
of_arg: (_: Vale.Interop.X64.reg_nat n -> Vale.X64.Machine_s.reg_64) ->
regs_mod: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
reserved_regs: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
reg_names: (_: Vale.X64.Machine_s.reg_64 -> Prims.string) ->
counter: Prims.nat ->
arg_names: (_: Prims.nat -> Prims.string)
-> (Prims.list Prims.string * (_: Vale.X64.Machine_s.reg_64 -> Prims.string)) * Prims.nat | {
"end_col": 36,
"end_line": 117,
"start_col": 3,
"start_line": 113
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let print_register_ret (reserved:reg_64 -> bool) = function
| None -> ""
| Some name -> if reserved rRax then " register uint64_t " ^ name ^ " __asm__(\"rax\");\n" else " uint64_t " ^ name ^ ";\n" | let print_register_ret (reserved: (reg_64 -> bool)) = | false | null | false | function
| None -> ""
| Some name ->
if reserved rRax
then " register uint64_t " ^ name ^ " __asm__(\"rax\");\n"
else " uint64_t " ^ name ^ ";\n" | {
"checked_file": "Vale.X64.Print_Inline_s.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Print_Inline_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_s.reg_64",
"Prims.bool",
"FStar.Pervasives.Native.option",
"Prims.string",
"Vale.X64.Machine_s.rRax",
"Prims.op_Hat"
] | [] | module Vale.X64.Print_Inline_s
open FStar.Mul
open FStar.List.Tot
open Vale.X64.Machine_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Instruction_s
open FStar.IO
open Vale.Interop.Base
open Vale.Interop.X64
module P = Vale.X64.Print_s
let print_rettype (ret_val:option string) = match ret_val with
| None -> "void"
| Some _ -> "uint64_t"
let print_basetype (t:base_typ) = match t with
| TUInt8 -> "uint8_t"
| TUInt16 -> "uint16_t"
| TUInt32 -> "uint32_t"
| TUInt64 -> "uint64_t"
| TUInt128 -> "ERROR"
// Returns "uint8_t arg2" or "uint64_t* arg0" for instance
let print_arg (a:td) (i:nat) (names:nat -> string) = match a with
| TD_Base src -> print_basetype src ^ " " ^ names i
| TD_Buffer src _ _ | TD_ImmBuffer src _ _ -> print_basetype src ^ " *" ^ names i
// Prints a list of args with their types, separated by a comma
let rec print_args (args:list td) (i:nat) (names:nat -> string) = match args with
| [] -> ""
| [a] -> print_arg a i names
| a::q -> print_arg a i names ^ ", " ^ print_args q (i+1) names
let rec build_reserved_args_outs (l:list instr_out) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let (_, op) = hd in
let reserved : (reg_64 -> bool) = (fun r ->
match op with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_outs tl reserved r
let rec build_reserved_args_ins (l:list instr_operand) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let reserved : (reg_64 -> bool) = (fun r ->
match hd with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_ins tl reserved r
// Traverses code, looking for instructions implicitly using registers.
// When found, mark such registers as reserved so that they are not used during implicit allocation
let rec build_reserved_args (c:code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases c) =
fun r ->
(match c with
| Ins ins -> begin
match ins with
| Instr i _ _ ->
let reserved = build_reserved_args_outs i.outs reserved in
let reserved = build_reserved_args_ins (InstrTypeRecord?.args i) reserved in
reserved r
| _ -> reserved r
end
| Block l -> (build_reserved_args_block l reserved) r
| IfElse cond ifTrue ifFalse ->
let reservedT = build_reserved_args ifTrue reserved in
build_reserved_args ifFalse reservedT r
| While cond body -> build_reserved_args body reserved r
)
and build_reserved_args_block (l:list code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r -> (
match l with
| [] -> reserved r
| hd::tl ->
let reserved = build_reserved_args hd reserved in
build_reserved_args_block tl reserved r
)
// Prints `"=&r" (name)` if an output is specified
let print_output_ret ret_val (reg_names:reg_64 -> string) (counter:nat) : list string & (reg_64 -> string) & nat
= match ret_val with
| None -> [], reg_names, counter
| Some name -> (["\"=&r\" (" ^ name ^ ")"],
// If r = rax then address it as current arg number
(fun r -> if r = 0 then string_of_int counter else reg_names r),
counter + 1)
// If the register in which a is passed is modified, we should specify `"+&r" (name)`
let print_modified_input
(n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then
(["\"+&r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1
) else ([], reg_names, counter)
// Get a list of strings corresponding to modified inputs
let rec get_modified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{i + List.Tot.length args <= n}) (ret_val:option string)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat
= match args with
| [] -> print_output_ret ret_val reg_names counter
| a::q ->
let output, reg_names, counter = print_modified_input n a i of_arg regs_mod reserved_regs reg_names counter arg_names in
let outputs, reg_names, counter = get_modified_input_strings n of_arg regs_mod reserved_regs q (i+1) ret_val reg_names counter arg_names in
output @ outputs, reg_names, counter
// Print the list of modified inputs, separated by commas
let print_modified_inputs
(n:nat)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n})
(ret_val:option string)
(reg_names:reg_64 -> string)
(counter:nat)
(arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let outputs, output_reg_names, output_nbr = get_modified_input_strings n of_arg regs_mod reserved_regs args 0 ret_val reg_names counter arg_names in
aux outputs, output_reg_names, output_nbr
// If the register in which an arg is passed is not modified, we should specify it as `"r" (name)`
let print_nonmodified_input
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(a:td) (i:nat{i < n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then ([], reg_names, counter) else
(["\"r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1)
// Get a list of strings corresponding to modified inputs
let rec get_nonmodified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{List.Tot.length args + i <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string)
= match args with
| [] -> [], reg_names, counter
| a::q ->
let input, reg_names, counter = print_nonmodified_input n of_arg regs_mod reserved_regs a i reg_names counter arg_names in
let inputs, reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs q (i+1) reg_names counter arg_names in
input @ inputs, reg_names, counter
let print_nonmodified_inputs
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let inputs, input_reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs args 0 reg_names counter arg_names in
aux inputs, input_reg_names, counter
// Print the list of modified registers, + memory and cc
let print_modified_registers
(n:nat)
(ret_val:option string)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_args:reg_64 -> bool)
(args:list td) =
// This register was already specified as output
let output_register a = Some? ret_val && a = rRax in
let rec input_register (i:nat) (a:reg_64) : Tot bool (decreases (n-i)) =
if i >= n then false
else
a = of_arg i // This register was already specified for the i-th argument
|| input_register (i+1) a
in
let rec aux = function
| [] -> "\"memory\", \"cc\"\n"
| a::q ->
// This register is not modified, or was already specified as input or output: we skip it
if not (regs_mod a) || input_register 0 a || output_register a then aux q
// Register not modified or already specified in inputs, we add it
else "\"%" ^ P.print_reg_name a ^ "\", " ^ aux q
in aux [rRax; rRbx; rRcx; rRdx; rRsi; rRdi; rRbp; rRsp; rR8; rR9; rR10; rR11; rR12; rR13; rR14; rR15]
// Prints "register uint64_t *argi_r __asm__("[reg]") = argi;\n"
let print_explicit_register_arg (n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (reserved:reg_64 -> bool) (names:nat -> string) =
let ty = match a with
| TD_Base _ -> "uint64_t "
| _ -> "uint64_t *"
in
if reserved (of_arg i) then
// If the associated register is reserved, we really this argument in it. For instance if it is Rdx and we have Mul(x) instructions
true, " register " ^ ty ^ names i ^ "_r __asm__(\"" ^ P.print_reg_name (of_arg i) ^ "\") = " ^ names i ^ ";\n"
else false, ""
let rec print_explicit_register_args (n:nat) (args:list td) (i:nat{i + List.length args = n}) (of_arg:reg_nat n -> reg_64) (reserved:reg_64 -> bool) (names:nat -> string) =
match args with
| [] -> false, ""
| a::q ->
let was_explicit, explicit_str = print_explicit_register_arg n a i of_arg reserved names in
let are_explicit, rest_str = print_explicit_register_args n q (i+1) of_arg reserved names in
was_explicit || are_explicit, explicit_str ^ rest_str | false | true | Vale.X64.Print_Inline_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val print_register_ret : reserved: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
_: FStar.Pervasives.Native.option Prims.string
-> Prims.string | [] | Vale.X64.Print_Inline_s.print_register_ret | {
"file_name": "vale/specs/hardware/Vale.X64.Print_Inline_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
reserved: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
_: FStar.Pervasives.Native.option Prims.string
-> Prims.string | {
"end_col": 127,
"end_line": 228,
"start_col": 51,
"start_line": 226
} |
|
Prims.Tot | val print_spaces (n: nat) : string | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec print_spaces (n:nat) : string =
match n with
| 0 -> ""
| n -> " " ^ print_spaces (n-1) | val print_spaces (n: nat) : string
let rec print_spaces (n: nat) : string = | false | null | false | match n with
| 0 -> ""
| n -> " " ^ print_spaces (n - 1) | {
"checked_file": "Vale.X64.Print_Inline_s.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Print_Inline_s.fst"
} | [
"total"
] | [
"Prims.nat",
"Prims.int",
"Prims.op_Hat",
"Vale.X64.Print_Inline_s.print_spaces",
"Prims.op_Subtraction",
"Prims.string"
] | [] | module Vale.X64.Print_Inline_s
open FStar.Mul
open FStar.List.Tot
open Vale.X64.Machine_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Instruction_s
open FStar.IO
open Vale.Interop.Base
open Vale.Interop.X64
module P = Vale.X64.Print_s
let print_rettype (ret_val:option string) = match ret_val with
| None -> "void"
| Some _ -> "uint64_t"
let print_basetype (t:base_typ) = match t with
| TUInt8 -> "uint8_t"
| TUInt16 -> "uint16_t"
| TUInt32 -> "uint32_t"
| TUInt64 -> "uint64_t"
| TUInt128 -> "ERROR"
// Returns "uint8_t arg2" or "uint64_t* arg0" for instance
let print_arg (a:td) (i:nat) (names:nat -> string) = match a with
| TD_Base src -> print_basetype src ^ " " ^ names i
| TD_Buffer src _ _ | TD_ImmBuffer src _ _ -> print_basetype src ^ " *" ^ names i
// Prints a list of args with their types, separated by a comma
let rec print_args (args:list td) (i:nat) (names:nat -> string) = match args with
| [] -> ""
| [a] -> print_arg a i names
| a::q -> print_arg a i names ^ ", " ^ print_args q (i+1) names
let rec build_reserved_args_outs (l:list instr_out) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let (_, op) = hd in
let reserved : (reg_64 -> bool) = (fun r ->
match op with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_outs tl reserved r
let rec build_reserved_args_ins (l:list instr_operand) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let reserved : (reg_64 -> bool) = (fun r ->
match hd with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_ins tl reserved r
// Traverses code, looking for instructions implicitly using registers.
// When found, mark such registers as reserved so that they are not used during implicit allocation
let rec build_reserved_args (c:code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases c) =
fun r ->
(match c with
| Ins ins -> begin
match ins with
| Instr i _ _ ->
let reserved = build_reserved_args_outs i.outs reserved in
let reserved = build_reserved_args_ins (InstrTypeRecord?.args i) reserved in
reserved r
| _ -> reserved r
end
| Block l -> (build_reserved_args_block l reserved) r
| IfElse cond ifTrue ifFalse ->
let reservedT = build_reserved_args ifTrue reserved in
build_reserved_args ifFalse reservedT r
| While cond body -> build_reserved_args body reserved r
)
and build_reserved_args_block (l:list code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r -> (
match l with
| [] -> reserved r
| hd::tl ->
let reserved = build_reserved_args hd reserved in
build_reserved_args_block tl reserved r
)
// Prints `"=&r" (name)` if an output is specified
let print_output_ret ret_val (reg_names:reg_64 -> string) (counter:nat) : list string & (reg_64 -> string) & nat
= match ret_val with
| None -> [], reg_names, counter
| Some name -> (["\"=&r\" (" ^ name ^ ")"],
// If r = rax then address it as current arg number
(fun r -> if r = 0 then string_of_int counter else reg_names r),
counter + 1)
// If the register in which a is passed is modified, we should specify `"+&r" (name)`
let print_modified_input
(n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then
(["\"+&r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1
) else ([], reg_names, counter)
// Get a list of strings corresponding to modified inputs
let rec get_modified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{i + List.Tot.length args <= n}) (ret_val:option string)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat
= match args with
| [] -> print_output_ret ret_val reg_names counter
| a::q ->
let output, reg_names, counter = print_modified_input n a i of_arg regs_mod reserved_regs reg_names counter arg_names in
let outputs, reg_names, counter = get_modified_input_strings n of_arg regs_mod reserved_regs q (i+1) ret_val reg_names counter arg_names in
output @ outputs, reg_names, counter
// Print the list of modified inputs, separated by commas
let print_modified_inputs
(n:nat)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n})
(ret_val:option string)
(reg_names:reg_64 -> string)
(counter:nat)
(arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let outputs, output_reg_names, output_nbr = get_modified_input_strings n of_arg regs_mod reserved_regs args 0 ret_val reg_names counter arg_names in
aux outputs, output_reg_names, output_nbr
// If the register in which an arg is passed is not modified, we should specify it as `"r" (name)`
let print_nonmodified_input
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(a:td) (i:nat{i < n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then ([], reg_names, counter) else
(["\"r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1)
// Get a list of strings corresponding to modified inputs
let rec get_nonmodified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{List.Tot.length args + i <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string)
= match args with
| [] -> [], reg_names, counter
| a::q ->
let input, reg_names, counter = print_nonmodified_input n of_arg regs_mod reserved_regs a i reg_names counter arg_names in
let inputs, reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs q (i+1) reg_names counter arg_names in
input @ inputs, reg_names, counter
let print_nonmodified_inputs
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let inputs, input_reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs args 0 reg_names counter arg_names in
aux inputs, input_reg_names, counter
// Print the list of modified registers, + memory and cc
let print_modified_registers
(n:nat)
(ret_val:option string)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_args:reg_64 -> bool)
(args:list td) =
// This register was already specified as output
let output_register a = Some? ret_val && a = rRax in
let rec input_register (i:nat) (a:reg_64) : Tot bool (decreases (n-i)) =
if i >= n then false
else
a = of_arg i // This register was already specified for the i-th argument
|| input_register (i+1) a
in
let rec aux = function
| [] -> "\"memory\", \"cc\"\n"
| a::q ->
// This register is not modified, or was already specified as input or output: we skip it
if not (regs_mod a) || input_register 0 a || output_register a then aux q
// Register not modified or already specified in inputs, we add it
else "\"%" ^ P.print_reg_name a ^ "\", " ^ aux q
in aux [rRax; rRbx; rRcx; rRdx; rRsi; rRdi; rRbp; rRsp; rR8; rR9; rR10; rR11; rR12; rR13; rR14; rR15]
// Prints "register uint64_t *argi_r __asm__("[reg]") = argi;\n"
let print_explicit_register_arg (n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (reserved:reg_64 -> bool) (names:nat -> string) =
let ty = match a with
| TD_Base _ -> "uint64_t "
| _ -> "uint64_t *"
in
if reserved (of_arg i) then
// If the associated register is reserved, we really this argument in it. For instance if it is Rdx and we have Mul(x) instructions
true, " register " ^ ty ^ names i ^ "_r __asm__(\"" ^ P.print_reg_name (of_arg i) ^ "\") = " ^ names i ^ ";\n"
else false, ""
let rec print_explicit_register_args (n:nat) (args:list td) (i:nat{i + List.length args = n}) (of_arg:reg_nat n -> reg_64) (reserved:reg_64 -> bool) (names:nat -> string) =
match args with
| [] -> false, ""
| a::q ->
let was_explicit, explicit_str = print_explicit_register_arg n a i of_arg reserved names in
let are_explicit, rest_str = print_explicit_register_args n q (i+1) of_arg reserved names in
was_explicit || are_explicit, explicit_str ^ rest_str
// If we have a return parameter with a reserved register, print "register uint64_t [name] __asm__("rax");\n"
let print_register_ret (reserved:reg_64 -> bool) = function
| None -> ""
| Some name -> if reserved rRax then " register uint64_t " ^ name ^ " __asm__(\"rax\");\n" else " uint64_t " ^ name ^ ";\n"
(* This is a copy from X64.Print_s, and should remain in sync. The difference is that
each line should be in quotes, and end by a semicolon in inline assembly *)
let print_cmp (c:ocmp) (counter:int) (p:P.printer) : string =
let print_ops (o1:operand64) (o2:operand64) : string =
let first, second = p.P.op_order (P.print_operand o1 p) (P.print_operand o2 p) in
" cmp " ^ first ^ ", " ^ second ^ "\n"
in
match c with
| OEq o1 o2 -> " \"" ^ print_ops o1 o2 ^ " je " ^ "L" ^ string_of_int counter ^ ";\"\n"
| ONe o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jne "^ "L" ^ string_of_int counter ^ ";\"\n"
| OLe o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jbe "^ "L" ^ string_of_int counter ^ ";\"\n"
| OGe o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jae "^ "L" ^ string_of_int counter ^ ";\"\n"
| OLt o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jb " ^ "L" ^ string_of_int counter ^ ";\"\n"
| OGt o1 o2 -> " \"" ^ print_ops o1 o2 ^ " ja " ^ "L" ^ string_of_int counter ^ ";\"\n" | false | true | Vale.X64.Print_Inline_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val print_spaces (n: nat) : string | [
"recursion"
] | Vale.X64.Print_Inline_s.print_spaces | {
"file_name": "vale/specs/hardware/Vale.X64.Print_Inline_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | n: Prims.nat -> Prims.string | {
"end_col": 33,
"end_line": 248,
"start_col": 2,
"start_line": 246
} |
Prims.Tot | val print_nonmodified_input
(n: nat)
(of_arg: (reg_nat n -> reg_64))
(regs_mod reserved_regs: (reg_64 -> bool))
(a: td)
(i: nat{i < n})
(reg_names: (reg_64 -> string))
(counter: nat)
(arg_names: (nat -> string))
: list string & (reg_64 -> string) & nat | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let print_nonmodified_input
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(a:td) (i:nat{i < n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then ([], reg_names, counter) else
(["\"r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1) | val print_nonmodified_input
(n: nat)
(of_arg: (reg_nat n -> reg_64))
(regs_mod reserved_regs: (reg_64 -> bool))
(a: td)
(i: nat{i < n})
(reg_names: (reg_64 -> string))
(counter: nat)
(arg_names: (nat -> string))
: list string & (reg_64 -> string) & nat
let print_nonmodified_input
(n: nat)
(of_arg: (reg_nat n -> reg_64))
(regs_mod reserved_regs: (reg_64 -> bool))
(a: td)
(i: nat{i < n})
(reg_names: (reg_64 -> string))
(counter: nat)
(arg_names: (nat -> string))
: list string & (reg_64 -> string) & nat = | false | null | false | if regs_mod (of_arg i)
then ([], reg_names, counter)
else
(["\"r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1) | {
"checked_file": "Vale.X64.Print_Inline_s.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Print_Inline_s.fst"
} | [
"total"
] | [
"Prims.nat",
"Vale.Interop.X64.reg_nat",
"Vale.X64.Machine_s.reg_64",
"Prims.bool",
"Vale.Interop.Base.td",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.string",
"FStar.Pervasives.Native.Mktuple3",
"Prims.list",
"Prims.Nil",
"Prims.Cons",
"Prims.op_Hat",
"Prims.op_AmpAmp",
"Prims.op_Equality",
"Prims.op_Negation",
"Prims.string_of_int",
"Prims.op_Addition",
"FStar.Pervasives.Native.tuple3"
] | [] | module Vale.X64.Print_Inline_s
open FStar.Mul
open FStar.List.Tot
open Vale.X64.Machine_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Instruction_s
open FStar.IO
open Vale.Interop.Base
open Vale.Interop.X64
module P = Vale.X64.Print_s
let print_rettype (ret_val:option string) = match ret_val with
| None -> "void"
| Some _ -> "uint64_t"
let print_basetype (t:base_typ) = match t with
| TUInt8 -> "uint8_t"
| TUInt16 -> "uint16_t"
| TUInt32 -> "uint32_t"
| TUInt64 -> "uint64_t"
| TUInt128 -> "ERROR"
// Returns "uint8_t arg2" or "uint64_t* arg0" for instance
let print_arg (a:td) (i:nat) (names:nat -> string) = match a with
| TD_Base src -> print_basetype src ^ " " ^ names i
| TD_Buffer src _ _ | TD_ImmBuffer src _ _ -> print_basetype src ^ " *" ^ names i
// Prints a list of args with their types, separated by a comma
let rec print_args (args:list td) (i:nat) (names:nat -> string) = match args with
| [] -> ""
| [a] -> print_arg a i names
| a::q -> print_arg a i names ^ ", " ^ print_args q (i+1) names
let rec build_reserved_args_outs (l:list instr_out) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let (_, op) = hd in
let reserved : (reg_64 -> bool) = (fun r ->
match op with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_outs tl reserved r
let rec build_reserved_args_ins (l:list instr_operand) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let reserved : (reg_64 -> bool) = (fun r ->
match hd with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_ins tl reserved r
// Traverses code, looking for instructions implicitly using registers.
// When found, mark such registers as reserved so that they are not used during implicit allocation
let rec build_reserved_args (c:code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases c) =
fun r ->
(match c with
| Ins ins -> begin
match ins with
| Instr i _ _ ->
let reserved = build_reserved_args_outs i.outs reserved in
let reserved = build_reserved_args_ins (InstrTypeRecord?.args i) reserved in
reserved r
| _ -> reserved r
end
| Block l -> (build_reserved_args_block l reserved) r
| IfElse cond ifTrue ifFalse ->
let reservedT = build_reserved_args ifTrue reserved in
build_reserved_args ifFalse reservedT r
| While cond body -> build_reserved_args body reserved r
)
and build_reserved_args_block (l:list code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r -> (
match l with
| [] -> reserved r
| hd::tl ->
let reserved = build_reserved_args hd reserved in
build_reserved_args_block tl reserved r
)
// Prints `"=&r" (name)` if an output is specified
let print_output_ret ret_val (reg_names:reg_64 -> string) (counter:nat) : list string & (reg_64 -> string) & nat
= match ret_val with
| None -> [], reg_names, counter
| Some name -> (["\"=&r\" (" ^ name ^ ")"],
// If r = rax then address it as current arg number
(fun r -> if r = 0 then string_of_int counter else reg_names r),
counter + 1)
// If the register in which a is passed is modified, we should specify `"+&r" (name)`
let print_modified_input
(n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then
(["\"+&r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1
) else ([], reg_names, counter)
// Get a list of strings corresponding to modified inputs
let rec get_modified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{i + List.Tot.length args <= n}) (ret_val:option string)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat
= match args with
| [] -> print_output_ret ret_val reg_names counter
| a::q ->
let output, reg_names, counter = print_modified_input n a i of_arg regs_mod reserved_regs reg_names counter arg_names in
let outputs, reg_names, counter = get_modified_input_strings n of_arg regs_mod reserved_regs q (i+1) ret_val reg_names counter arg_names in
output @ outputs, reg_names, counter
// Print the list of modified inputs, separated by commas
let print_modified_inputs
(n:nat)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n})
(ret_val:option string)
(reg_names:reg_64 -> string)
(counter:nat)
(arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let outputs, output_reg_names, output_nbr = get_modified_input_strings n of_arg regs_mod reserved_regs args 0 ret_val reg_names counter arg_names in
aux outputs, output_reg_names, output_nbr
// If the register in which an arg is passed is not modified, we should specify it as `"r" (name)`
let print_nonmodified_input
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool) | false | false | Vale.X64.Print_Inline_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val print_nonmodified_input
(n: nat)
(of_arg: (reg_nat n -> reg_64))
(regs_mod reserved_regs: (reg_64 -> bool))
(a: td)
(i: nat{i < n})
(reg_names: (reg_64 -> string))
(counter: nat)
(arg_names: (nat -> string))
: list string & (reg_64 -> string) & nat | [] | Vale.X64.Print_Inline_s.print_nonmodified_input | {
"file_name": "vale/specs/hardware/Vale.X64.Print_Inline_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
n: Prims.nat ->
of_arg: (_: Vale.Interop.X64.reg_nat n -> Vale.X64.Machine_s.reg_64) ->
regs_mod: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
reserved_regs: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
a: Vale.Interop.Base.td ->
i: Prims.nat{i < n} ->
reg_names: (_: Vale.X64.Machine_s.reg_64 -> Prims.string) ->
counter: Prims.nat ->
arg_names: (_: Prims.nat -> Prims.string)
-> (Prims.list Prims.string * (_: Vale.X64.Machine_s.reg_64 -> Prims.string)) * Prims.nat | {
"end_col": 17,
"end_line": 157,
"start_col": 3,
"start_line": 154
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec print_args (args:list td) (i:nat) (names:nat -> string) = match args with
| [] -> ""
| [a] -> print_arg a i names
| a::q -> print_arg a i names ^ ", " ^ print_args q (i+1) names | let rec print_args (args: list td) (i: nat) (names: (nat -> string)) = | false | null | false | match args with
| [] -> ""
| [a] -> print_arg a i names
| a :: q -> print_arg a i names ^ ", " ^ print_args q (i + 1) names | {
"checked_file": "Vale.X64.Print_Inline_s.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Print_Inline_s.fst"
} | [
"total"
] | [
"Prims.list",
"Vale.Interop.Base.td",
"Prims.nat",
"Prims.string",
"Vale.X64.Print_Inline_s.print_arg",
"Prims.op_Hat",
"Vale.X64.Print_Inline_s.print_args",
"Prims.op_Addition"
] | [] | module Vale.X64.Print_Inline_s
open FStar.Mul
open FStar.List.Tot
open Vale.X64.Machine_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Instruction_s
open FStar.IO
open Vale.Interop.Base
open Vale.Interop.X64
module P = Vale.X64.Print_s
let print_rettype (ret_val:option string) = match ret_val with
| None -> "void"
| Some _ -> "uint64_t"
let print_basetype (t:base_typ) = match t with
| TUInt8 -> "uint8_t"
| TUInt16 -> "uint16_t"
| TUInt32 -> "uint32_t"
| TUInt64 -> "uint64_t"
| TUInt128 -> "ERROR"
// Returns "uint8_t arg2" or "uint64_t* arg0" for instance
let print_arg (a:td) (i:nat) (names:nat -> string) = match a with
| TD_Base src -> print_basetype src ^ " " ^ names i
| TD_Buffer src _ _ | TD_ImmBuffer src _ _ -> print_basetype src ^ " *" ^ names i | false | true | Vale.X64.Print_Inline_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val print_args : args: Prims.list Vale.Interop.Base.td -> i: Prims.nat -> names: (_: Prims.nat -> Prims.string)
-> Prims.string | [
"recursion"
] | Vale.X64.Print_Inline_s.print_args | {
"file_name": "vale/specs/hardware/Vale.X64.Print_Inline_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | args: Prims.list Vale.Interop.Base.td -> i: Prims.nat -> names: (_: Prims.nat -> Prims.string)
-> Prims.string | {
"end_col": 65,
"end_line": 34,
"start_col": 66,
"start_line": 31
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let print_basetype (t:base_typ) = match t with
| TUInt8 -> "uint8_t"
| TUInt16 -> "uint16_t"
| TUInt32 -> "uint32_t"
| TUInt64 -> "uint64_t"
| TUInt128 -> "ERROR" | let print_basetype (t: base_typ) = | false | null | false | match t with
| TUInt8 -> "uint8_t"
| TUInt16 -> "uint16_t"
| TUInt32 -> "uint32_t"
| TUInt64 -> "uint64_t"
| TUInt128 -> "ERROR" | {
"checked_file": "Vale.X64.Print_Inline_s.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Print_Inline_s.fst"
} | [
"total"
] | [
"Vale.Arch.HeapTypes_s.base_typ",
"Prims.string"
] | [] | module Vale.X64.Print_Inline_s
open FStar.Mul
open FStar.List.Tot
open Vale.X64.Machine_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Instruction_s
open FStar.IO
open Vale.Interop.Base
open Vale.Interop.X64
module P = Vale.X64.Print_s
let print_rettype (ret_val:option string) = match ret_val with
| None -> "void"
| Some _ -> "uint64_t" | false | true | Vale.X64.Print_Inline_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val print_basetype : t: Vale.Arch.HeapTypes_s.base_typ -> Prims.string | [] | Vale.X64.Print_Inline_s.print_basetype | {
"file_name": "vale/specs/hardware/Vale.X64.Print_Inline_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | t: Vale.Arch.HeapTypes_s.base_typ -> Prims.string | {
"end_col": 23,
"end_line": 23,
"start_col": 34,
"start_line": 18
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let print_arg (a:td) (i:nat) (names:nat -> string) = match a with
| TD_Base src -> print_basetype src ^ " " ^ names i
| TD_Buffer src _ _ | TD_ImmBuffer src _ _ -> print_basetype src ^ " *" ^ names i | let print_arg (a: td) (i: nat) (names: (nat -> string)) = | false | null | false | match a with
| TD_Base src -> print_basetype src ^ " " ^ names i
| TD_Buffer src _ _ | TD_ImmBuffer src _ _ -> print_basetype src ^ " *" ^ names i | {
"checked_file": "Vale.X64.Print_Inline_s.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Print_Inline_s.fst"
} | [
"total"
] | [
"Vale.Interop.Base.td",
"Prims.nat",
"Prims.string",
"Vale.Interop.Base.valid_base_type",
"Prims.op_Hat",
"Vale.X64.Print_Inline_s.print_basetype",
"Vale.Arch.HeapTypes_s.base_typ",
"Vale.Interop.Base.buffer_qualifiers"
] | [] | module Vale.X64.Print_Inline_s
open FStar.Mul
open FStar.List.Tot
open Vale.X64.Machine_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Instruction_s
open FStar.IO
open Vale.Interop.Base
open Vale.Interop.X64
module P = Vale.X64.Print_s
let print_rettype (ret_val:option string) = match ret_val with
| None -> "void"
| Some _ -> "uint64_t"
let print_basetype (t:base_typ) = match t with
| TUInt8 -> "uint8_t"
| TUInt16 -> "uint16_t"
| TUInt32 -> "uint32_t"
| TUInt64 -> "uint64_t"
| TUInt128 -> "ERROR" | false | true | Vale.X64.Print_Inline_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val print_arg : a: Vale.Interop.Base.td -> i: Prims.nat -> names: (_: Prims.nat -> Prims.string) -> Prims.string | [] | Vale.X64.Print_Inline_s.print_arg | {
"file_name": "vale/specs/hardware/Vale.X64.Print_Inline_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Interop.Base.td -> i: Prims.nat -> names: (_: Prims.nat -> Prims.string) -> Prims.string | {
"end_col": 83,
"end_line": 28,
"start_col": 53,
"start_line": 26
} |
|
Prims.Tot | val build_reserved_args_outs (l: list instr_out) (reserved: (reg_64 -> bool))
: Tot (reg_64 -> bool) (decreases l) | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec build_reserved_args_outs (l:list instr_out) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let (_, op) = hd in
let reserved : (reg_64 -> bool) = (fun r ->
match op with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_outs tl reserved r | val build_reserved_args_outs (l: list instr_out) (reserved: (reg_64 -> bool))
: Tot (reg_64 -> bool) (decreases l)
let rec build_reserved_args_outs (l: list instr_out) (reserved: (reg_64 -> bool))
: Tot (reg_64 -> bool) (decreases l) = | false | null | false | fun r ->
match l with
| [] -> reserved r
| hd :: tl ->
let _, op = hd in
let reserved:(reg_64 -> bool) =
(fun r ->
match op with
| IOpIm (IOp64One (OReg reg)) -> if r = reg then true else reserved r
| _ -> reserved r)
in
build_reserved_args_outs tl reserved r | {
"checked_file": "Vale.X64.Print_Inline_s.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Print_Inline_s.fst"
} | [
"total",
""
] | [
"Prims.list",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Machine_s.reg_64",
"Prims.bool",
"Vale.X64.Instruction_s.instr_operand_inout",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Print_Inline_s.build_reserved_args_outs",
"Prims.op_Equality"
] | [] | module Vale.X64.Print_Inline_s
open FStar.Mul
open FStar.List.Tot
open Vale.X64.Machine_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Instruction_s
open FStar.IO
open Vale.Interop.Base
open Vale.Interop.X64
module P = Vale.X64.Print_s
let print_rettype (ret_val:option string) = match ret_val with
| None -> "void"
| Some _ -> "uint64_t"
let print_basetype (t:base_typ) = match t with
| TUInt8 -> "uint8_t"
| TUInt16 -> "uint16_t"
| TUInt32 -> "uint32_t"
| TUInt64 -> "uint64_t"
| TUInt128 -> "ERROR"
// Returns "uint8_t arg2" or "uint64_t* arg0" for instance
let print_arg (a:td) (i:nat) (names:nat -> string) = match a with
| TD_Base src -> print_basetype src ^ " " ^ names i
| TD_Buffer src _ _ | TD_ImmBuffer src _ _ -> print_basetype src ^ " *" ^ names i
// Prints a list of args with their types, separated by a comma
let rec print_args (args:list td) (i:nat) (names:nat -> string) = match args with
| [] -> ""
| [a] -> print_arg a i names
| a::q -> print_arg a i names ^ ", " ^ print_args q (i+1) names
let rec build_reserved_args_outs (l:list instr_out) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool) | false | false | Vale.X64.Print_Inline_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val build_reserved_args_outs (l: list instr_out) (reserved: (reg_64 -> bool))
: Tot (reg_64 -> bool) (decreases l) | [
"recursion"
] | Vale.X64.Print_Inline_s.build_reserved_args_outs | {
"file_name": "vale/specs/hardware/Vale.X64.Print_Inline_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
l: Prims.list Vale.X64.Instruction_s.instr_out ->
reserved: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool)
-> Prims.Tot (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) | {
"end_col": 45,
"end_line": 50,
"start_col": 2,
"start_line": 39
} |
Prims.Tot | val build_reserved_args_ins (l: list instr_operand) (reserved: (reg_64 -> bool))
: Tot (reg_64 -> bool) (decreases l) | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec build_reserved_args_ins (l:list instr_operand) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let reserved : (reg_64 -> bool) = (fun r ->
match hd with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_ins tl reserved r | val build_reserved_args_ins (l: list instr_operand) (reserved: (reg_64 -> bool))
: Tot (reg_64 -> bool) (decreases l)
let rec build_reserved_args_ins (l: list instr_operand) (reserved: (reg_64 -> bool))
: Tot (reg_64 -> bool) (decreases l) = | false | null | false | fun r ->
match l with
| [] -> reserved r
| hd :: tl ->
let reserved:(reg_64 -> bool) =
(fun r ->
match hd with
| IOpIm (IOp64One (OReg reg)) -> if r = reg then true else reserved r
| _ -> reserved r)
in
build_reserved_args_ins tl reserved r | {
"checked_file": "Vale.X64.Print_Inline_s.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Print_Inline_s.fst"
} | [
"total",
""
] | [
"Prims.list",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Machine_s.reg_64",
"Prims.bool",
"Vale.X64.Print_Inline_s.build_reserved_args_ins",
"Prims.op_Equality"
] | [] | module Vale.X64.Print_Inline_s
open FStar.Mul
open FStar.List.Tot
open Vale.X64.Machine_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Instruction_s
open FStar.IO
open Vale.Interop.Base
open Vale.Interop.X64
module P = Vale.X64.Print_s
let print_rettype (ret_val:option string) = match ret_val with
| None -> "void"
| Some _ -> "uint64_t"
let print_basetype (t:base_typ) = match t with
| TUInt8 -> "uint8_t"
| TUInt16 -> "uint16_t"
| TUInt32 -> "uint32_t"
| TUInt64 -> "uint64_t"
| TUInt128 -> "ERROR"
// Returns "uint8_t arg2" or "uint64_t* arg0" for instance
let print_arg (a:td) (i:nat) (names:nat -> string) = match a with
| TD_Base src -> print_basetype src ^ " " ^ names i
| TD_Buffer src _ _ | TD_ImmBuffer src _ _ -> print_basetype src ^ " *" ^ names i
// Prints a list of args with their types, separated by a comma
let rec print_args (args:list td) (i:nat) (names:nat -> string) = match args with
| [] -> ""
| [a] -> print_arg a i names
| a::q -> print_arg a i names ^ ", " ^ print_args q (i+1) names
let rec build_reserved_args_outs (l:list instr_out) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let (_, op) = hd in
let reserved : (reg_64 -> bool) = (fun r ->
match op with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_outs tl reserved r
let rec build_reserved_args_ins (l:list instr_operand) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool) | false | false | Vale.X64.Print_Inline_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val build_reserved_args_ins (l: list instr_operand) (reserved: (reg_64 -> bool))
: Tot (reg_64 -> bool) (decreases l) | [
"recursion"
] | Vale.X64.Print_Inline_s.build_reserved_args_ins | {
"file_name": "vale/specs/hardware/Vale.X64.Print_Inline_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
l: Prims.list Vale.X64.Instruction_s.instr_operand ->
reserved: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool)
-> Prims.Tot (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) | {
"end_col": 44,
"end_line": 65,
"start_col": 2,
"start_line": 55
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec print_fn_comments = function
| [] -> ""
| hd::tl -> "// " ^ hd ^ "\n" ^ print_fn_comments tl | let rec print_fn_comments = | false | null | false | function
| [] -> ""
| hd :: tl -> "// " ^ hd ^ "\n" ^ print_fn_comments tl | {
"checked_file": "Vale.X64.Print_Inline_s.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Print_Inline_s.fst"
} | [
"total"
] | [
"Prims.list",
"Prims.string",
"Prims.op_Hat",
"Vale.X64.Print_Inline_s.print_fn_comments"
] | [] | module Vale.X64.Print_Inline_s
open FStar.Mul
open FStar.List.Tot
open Vale.X64.Machine_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Instruction_s
open FStar.IO
open Vale.Interop.Base
open Vale.Interop.X64
module P = Vale.X64.Print_s
let print_rettype (ret_val:option string) = match ret_val with
| None -> "void"
| Some _ -> "uint64_t"
let print_basetype (t:base_typ) = match t with
| TUInt8 -> "uint8_t"
| TUInt16 -> "uint16_t"
| TUInt32 -> "uint32_t"
| TUInt64 -> "uint64_t"
| TUInt128 -> "ERROR"
// Returns "uint8_t arg2" or "uint64_t* arg0" for instance
let print_arg (a:td) (i:nat) (names:nat -> string) = match a with
| TD_Base src -> print_basetype src ^ " " ^ names i
| TD_Buffer src _ _ | TD_ImmBuffer src _ _ -> print_basetype src ^ " *" ^ names i
// Prints a list of args with their types, separated by a comma
let rec print_args (args:list td) (i:nat) (names:nat -> string) = match args with
| [] -> ""
| [a] -> print_arg a i names
| a::q -> print_arg a i names ^ ", " ^ print_args q (i+1) names
let rec build_reserved_args_outs (l:list instr_out) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let (_, op) = hd in
let reserved : (reg_64 -> bool) = (fun r ->
match op with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_outs tl reserved r
let rec build_reserved_args_ins (l:list instr_operand) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let reserved : (reg_64 -> bool) = (fun r ->
match hd with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_ins tl reserved r
// Traverses code, looking for instructions implicitly using registers.
// When found, mark such registers as reserved so that they are not used during implicit allocation
let rec build_reserved_args (c:code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases c) =
fun r ->
(match c with
| Ins ins -> begin
match ins with
| Instr i _ _ ->
let reserved = build_reserved_args_outs i.outs reserved in
let reserved = build_reserved_args_ins (InstrTypeRecord?.args i) reserved in
reserved r
| _ -> reserved r
end
| Block l -> (build_reserved_args_block l reserved) r
| IfElse cond ifTrue ifFalse ->
let reservedT = build_reserved_args ifTrue reserved in
build_reserved_args ifFalse reservedT r
| While cond body -> build_reserved_args body reserved r
)
and build_reserved_args_block (l:list code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r -> (
match l with
| [] -> reserved r
| hd::tl ->
let reserved = build_reserved_args hd reserved in
build_reserved_args_block tl reserved r
)
// Prints `"=&r" (name)` if an output is specified
let print_output_ret ret_val (reg_names:reg_64 -> string) (counter:nat) : list string & (reg_64 -> string) & nat
= match ret_val with
| None -> [], reg_names, counter
| Some name -> (["\"=&r\" (" ^ name ^ ")"],
// If r = rax then address it as current arg number
(fun r -> if r = 0 then string_of_int counter else reg_names r),
counter + 1)
// If the register in which a is passed is modified, we should specify `"+&r" (name)`
let print_modified_input
(n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then
(["\"+&r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1
) else ([], reg_names, counter)
// Get a list of strings corresponding to modified inputs
let rec get_modified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{i + List.Tot.length args <= n}) (ret_val:option string)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat
= match args with
| [] -> print_output_ret ret_val reg_names counter
| a::q ->
let output, reg_names, counter = print_modified_input n a i of_arg regs_mod reserved_regs reg_names counter arg_names in
let outputs, reg_names, counter = get_modified_input_strings n of_arg regs_mod reserved_regs q (i+1) ret_val reg_names counter arg_names in
output @ outputs, reg_names, counter
// Print the list of modified inputs, separated by commas
let print_modified_inputs
(n:nat)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n})
(ret_val:option string)
(reg_names:reg_64 -> string)
(counter:nat)
(arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let outputs, output_reg_names, output_nbr = get_modified_input_strings n of_arg regs_mod reserved_regs args 0 ret_val reg_names counter arg_names in
aux outputs, output_reg_names, output_nbr
// If the register in which an arg is passed is not modified, we should specify it as `"r" (name)`
let print_nonmodified_input
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(a:td) (i:nat{i < n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then ([], reg_names, counter) else
(["\"r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1)
// Get a list of strings corresponding to modified inputs
let rec get_nonmodified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{List.Tot.length args + i <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string)
= match args with
| [] -> [], reg_names, counter
| a::q ->
let input, reg_names, counter = print_nonmodified_input n of_arg regs_mod reserved_regs a i reg_names counter arg_names in
let inputs, reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs q (i+1) reg_names counter arg_names in
input @ inputs, reg_names, counter
let print_nonmodified_inputs
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let inputs, input_reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs args 0 reg_names counter arg_names in
aux inputs, input_reg_names, counter
// Print the list of modified registers, + memory and cc
let print_modified_registers
(n:nat)
(ret_val:option string)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_args:reg_64 -> bool)
(args:list td) =
// This register was already specified as output
let output_register a = Some? ret_val && a = rRax in
let rec input_register (i:nat) (a:reg_64) : Tot bool (decreases (n-i)) =
if i >= n then false
else
a = of_arg i // This register was already specified for the i-th argument
|| input_register (i+1) a
in
let rec aux = function
| [] -> "\"memory\", \"cc\"\n"
| a::q ->
// This register is not modified, or was already specified as input or output: we skip it
if not (regs_mod a) || input_register 0 a || output_register a then aux q
// Register not modified or already specified in inputs, we add it
else "\"%" ^ P.print_reg_name a ^ "\", " ^ aux q
in aux [rRax; rRbx; rRcx; rRdx; rRsi; rRdi; rRbp; rRsp; rR8; rR9; rR10; rR11; rR12; rR13; rR14; rR15]
// Prints "register uint64_t *argi_r __asm__("[reg]") = argi;\n"
let print_explicit_register_arg (n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (reserved:reg_64 -> bool) (names:nat -> string) =
let ty = match a with
| TD_Base _ -> "uint64_t "
| _ -> "uint64_t *"
in
if reserved (of_arg i) then
// If the associated register is reserved, we really this argument in it. For instance if it is Rdx and we have Mul(x) instructions
true, " register " ^ ty ^ names i ^ "_r __asm__(\"" ^ P.print_reg_name (of_arg i) ^ "\") = " ^ names i ^ ";\n"
else false, ""
let rec print_explicit_register_args (n:nat) (args:list td) (i:nat{i + List.length args = n}) (of_arg:reg_nat n -> reg_64) (reserved:reg_64 -> bool) (names:nat -> string) =
match args with
| [] -> false, ""
| a::q ->
let was_explicit, explicit_str = print_explicit_register_arg n a i of_arg reserved names in
let are_explicit, rest_str = print_explicit_register_args n q (i+1) of_arg reserved names in
was_explicit || are_explicit, explicit_str ^ rest_str
// If we have a return parameter with a reserved register, print "register uint64_t [name] __asm__("rax");\n"
let print_register_ret (reserved:reg_64 -> bool) = function
| None -> ""
| Some name -> if reserved rRax then " register uint64_t " ^ name ^ " __asm__(\"rax\");\n" else " uint64_t " ^ name ^ ";\n"
(* This is a copy from X64.Print_s, and should remain in sync. The difference is that
each line should be in quotes, and end by a semicolon in inline assembly *)
let print_cmp (c:ocmp) (counter:int) (p:P.printer) : string =
let print_ops (o1:operand64) (o2:operand64) : string =
let first, second = p.P.op_order (P.print_operand o1 p) (P.print_operand o2 p) in
" cmp " ^ first ^ ", " ^ second ^ "\n"
in
match c with
| OEq o1 o2 -> " \"" ^ print_ops o1 o2 ^ " je " ^ "L" ^ string_of_int counter ^ ";\"\n"
| ONe o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jne "^ "L" ^ string_of_int counter ^ ";\"\n"
| OLe o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jbe "^ "L" ^ string_of_int counter ^ ";\"\n"
| OGe o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jae "^ "L" ^ string_of_int counter ^ ";\"\n"
| OLt o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jb " ^ "L" ^ string_of_int counter ^ ";\"\n"
| OGt o1 o2 -> " \"" ^ print_ops o1 o2 ^ " ja " ^ "L" ^ string_of_int counter ^ ";\"\n"
let rec print_spaces (n:nat) : string =
match n with
| 0 -> ""
| n -> " " ^ print_spaces (n-1)
(* Overriding printer for formatting instructions *)
let print_ins (ins:ins) (p:P.printer) : string =
match ins with
| Instr _ _ (AnnotateComment s) -> " // " ^ s
| Instr _ _ (AnnotateLargeComment s) -> "\n /////// " ^ s ^ " ////// \n"
| Instr _ _ (AnnotateSpace n) -> print_spaces n
| _ -> " \"" ^ P.print_ins ins p ^ ";\""
let rec print_block (b:codes) (n:int) (p:P.printer) : string & int =
match b with
| Nil -> "", n
| Ins (Instr _ _ (AnnotateSpace spaces)) :: Ins (Instr _ _ (AnnotateComment s)) :: tail ->
let head_str = " // " ^ s ^ "\n" in
let rest, n' = print_block tail n p in
print_spaces spaces ^ head_str ^ rest, n'
| Ins (Instr _ _ (AnnotateSpace spaces)) :: Ins i :: tail ->
let head_str = print_ins i p in
let rest, n' = print_block tail n p in
print_spaces spaces ^ head_str ^ rest, n'
| Ins (Instr _ _ (AnnotateNewline _)) :: tail ->
let rest, n' = print_block tail n p in
"\n" ^ rest, n'
| head :: tail ->
let head_str, n' = print_code head n p in
let rest, n'' = print_block tail n' p in
head_str ^ rest, n''
and print_code (c:code) (n:int) (p:P.printer) : string & int =
match c with
| Ins ins -> (print_ins ins p ^ "\n", n)
| Block b -> print_block b n p
| IfElse cond true_code false_code ->
let n1 = n in
let n2 = n + 1 in
let cmp = print_cmp (P.cmp_not cond) n1 p in
let true_str, n' = print_code true_code (n + 2) p in
let jmp = " \" jmp L" ^ string_of_int n2 ^ ";\"\n" in
let label1 = " \"L" ^ string_of_int n1 ^ ":\"\n" in
let false_str, n' = print_code false_code n' p in
let label2 = " \"L" ^ string_of_int n2 ^ ":\"\n" in
cmp ^ true_str ^ jmp ^ label1 ^ false_str ^ label2, n'
| While cond body ->
let n1 = n in
let n2 = n + 1 in
let jmp = " \" jmp L" ^ string_of_int n2 ^ ";\"\n" in
let label1 = " \"" ^ p.P.align() ^ " 16\nL" ^ string_of_int n1 ^ ":\"\n" in
let body_str, n' = print_code body (n + 2) p in
let label2 = " \"" ^ p.P.align() ^ " 16\nL" ^ string_of_int n2 ^ ":\"\n" in
let cmp = print_cmp cond n1 p in
jmp ^ label1 ^ body_str ^ label2 ^ cmp, n' | false | true | Vale.X64.Print_Inline_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val print_fn_comments : _: Prims.list Prims.string -> Prims.string | [
"recursion"
] | Vale.X64.Print_Inline_s.print_fn_comments | {
"file_name": "vale/specs/hardware/Vale.X64.Print_Inline_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.list Prims.string -> Prims.string | {
"end_col": 54,
"end_line": 302,
"start_col": 28,
"start_line": 300
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let print_nonmodified_inputs
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let inputs, input_reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs args 0 reg_names counter arg_names in
aux inputs, input_reg_names, counter | let print_nonmodified_inputs
(n: nat)
(of_arg: (reg_nat n -> reg_64))
(regs_mod reserved_regs: (reg_64 -> bool))
(args: list td {List.Tot.length args <= n})
(reg_names: (reg_64 -> string))
(counter: nat)
(arg_names: (nat -> string))
= | false | null | false | let rec aux =
function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let inputs, input_reg_names, counter =
get_nonmodified_input_strings n of_arg regs_mod reserved_regs args 0 reg_names counter arg_names
in
aux inputs, input_reg_names, counter | {
"checked_file": "Vale.X64.Print_Inline_s.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Print_Inline_s.fst"
} | [
"total"
] | [
"Prims.nat",
"Vale.Interop.X64.reg_nat",
"Vale.X64.Machine_s.reg_64",
"Prims.bool",
"Prims.list",
"Vale.Interop.Base.td",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.List.Tot.Base.length",
"Prims.string",
"FStar.Pervasives.Native.Mktuple3",
"FStar.Pervasives.Native.tuple3",
"Vale.X64.Print_Inline_s.get_nonmodified_input_strings",
"Prims.op_Hat"
] | [] | module Vale.X64.Print_Inline_s
open FStar.Mul
open FStar.List.Tot
open Vale.X64.Machine_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Instruction_s
open FStar.IO
open Vale.Interop.Base
open Vale.Interop.X64
module P = Vale.X64.Print_s
let print_rettype (ret_val:option string) = match ret_val with
| None -> "void"
| Some _ -> "uint64_t"
let print_basetype (t:base_typ) = match t with
| TUInt8 -> "uint8_t"
| TUInt16 -> "uint16_t"
| TUInt32 -> "uint32_t"
| TUInt64 -> "uint64_t"
| TUInt128 -> "ERROR"
// Returns "uint8_t arg2" or "uint64_t* arg0" for instance
let print_arg (a:td) (i:nat) (names:nat -> string) = match a with
| TD_Base src -> print_basetype src ^ " " ^ names i
| TD_Buffer src _ _ | TD_ImmBuffer src _ _ -> print_basetype src ^ " *" ^ names i
// Prints a list of args with their types, separated by a comma
let rec print_args (args:list td) (i:nat) (names:nat -> string) = match args with
| [] -> ""
| [a] -> print_arg a i names
| a::q -> print_arg a i names ^ ", " ^ print_args q (i+1) names
let rec build_reserved_args_outs (l:list instr_out) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let (_, op) = hd in
let reserved : (reg_64 -> bool) = (fun r ->
match op with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_outs tl reserved r
let rec build_reserved_args_ins (l:list instr_operand) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let reserved : (reg_64 -> bool) = (fun r ->
match hd with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_ins tl reserved r
// Traverses code, looking for instructions implicitly using registers.
// When found, mark such registers as reserved so that they are not used during implicit allocation
let rec build_reserved_args (c:code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases c) =
fun r ->
(match c with
| Ins ins -> begin
match ins with
| Instr i _ _ ->
let reserved = build_reserved_args_outs i.outs reserved in
let reserved = build_reserved_args_ins (InstrTypeRecord?.args i) reserved in
reserved r
| _ -> reserved r
end
| Block l -> (build_reserved_args_block l reserved) r
| IfElse cond ifTrue ifFalse ->
let reservedT = build_reserved_args ifTrue reserved in
build_reserved_args ifFalse reservedT r
| While cond body -> build_reserved_args body reserved r
)
and build_reserved_args_block (l:list code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r -> (
match l with
| [] -> reserved r
| hd::tl ->
let reserved = build_reserved_args hd reserved in
build_reserved_args_block tl reserved r
)
// Prints `"=&r" (name)` if an output is specified
let print_output_ret ret_val (reg_names:reg_64 -> string) (counter:nat) : list string & (reg_64 -> string) & nat
= match ret_val with
| None -> [], reg_names, counter
| Some name -> (["\"=&r\" (" ^ name ^ ")"],
// If r = rax then address it as current arg number
(fun r -> if r = 0 then string_of_int counter else reg_names r),
counter + 1)
// If the register in which a is passed is modified, we should specify `"+&r" (name)`
let print_modified_input
(n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then
(["\"+&r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1
) else ([], reg_names, counter)
// Get a list of strings corresponding to modified inputs
let rec get_modified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{i + List.Tot.length args <= n}) (ret_val:option string)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat
= match args with
| [] -> print_output_ret ret_val reg_names counter
| a::q ->
let output, reg_names, counter = print_modified_input n a i of_arg regs_mod reserved_regs reg_names counter arg_names in
let outputs, reg_names, counter = get_modified_input_strings n of_arg regs_mod reserved_regs q (i+1) ret_val reg_names counter arg_names in
output @ outputs, reg_names, counter
// Print the list of modified inputs, separated by commas
let print_modified_inputs
(n:nat)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n})
(ret_val:option string)
(reg_names:reg_64 -> string)
(counter:nat)
(arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let outputs, output_reg_names, output_nbr = get_modified_input_strings n of_arg regs_mod reserved_regs args 0 ret_val reg_names counter arg_names in
aux outputs, output_reg_names, output_nbr
// If the register in which an arg is passed is not modified, we should specify it as `"r" (name)`
let print_nonmodified_input
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(a:td) (i:nat{i < n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then ([], reg_names, counter) else
(["\"r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1)
// Get a list of strings corresponding to modified inputs
let rec get_nonmodified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{List.Tot.length args + i <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string)
= match args with
| [] -> [], reg_names, counter
| a::q ->
let input, reg_names, counter = print_nonmodified_input n of_arg regs_mod reserved_regs a i reg_names counter arg_names in
let inputs, reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs q (i+1) reg_names counter arg_names in
input @ inputs, reg_names, counter
let print_nonmodified_inputs | false | false | Vale.X64.Print_Inline_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val print_nonmodified_inputs : n: Prims.nat ->
of_arg: (_: Vale.Interop.X64.reg_nat n -> Vale.X64.Machine_s.reg_64) ->
regs_mod: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
reserved_regs: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
args: Prims.list Vale.Interop.Base.td {FStar.List.Tot.Base.length args <= n} ->
reg_names: (_: Vale.X64.Machine_s.reg_64 -> Prims.string) ->
counter: Prims.nat ->
arg_names: (_: Prims.nat -> Prims.string)
-> (Prims.string * (_: Vale.X64.Machine_s.reg_64 -> Prims.string)) * Prims.nat | [] | Vale.X64.Print_Inline_s.print_nonmodified_inputs | {
"file_name": "vale/specs/hardware/Vale.X64.Print_Inline_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
n: Prims.nat ->
of_arg: (_: Vale.Interop.X64.reg_nat n -> Vale.X64.Machine_s.reg_64) ->
regs_mod: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
reserved_regs: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
args: Prims.list Vale.Interop.Base.td {FStar.List.Tot.Base.length args <= n} ->
reg_names: (_: Vale.X64.Machine_s.reg_64 -> Prims.string) ->
counter: Prims.nat ->
arg_names: (_: Prims.nat -> Prims.string)
-> (Prims.string * (_: Vale.X64.Machine_s.reg_64 -> Prims.string)) * Prims.nat | {
"end_col": 38,
"end_line": 179,
"start_col": 114,
"start_line": 172
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let print_modified_registers
(n:nat)
(ret_val:option string)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_args:reg_64 -> bool)
(args:list td) =
// This register was already specified as output
let output_register a = Some? ret_val && a = rRax in
let rec input_register (i:nat) (a:reg_64) : Tot bool (decreases (n-i)) =
if i >= n then false
else
a = of_arg i // This register was already specified for the i-th argument
|| input_register (i+1) a
in
let rec aux = function
| [] -> "\"memory\", \"cc\"\n"
| a::q ->
// This register is not modified, or was already specified as input or output: we skip it
if not (regs_mod a) || input_register 0 a || output_register a then aux q
// Register not modified or already specified in inputs, we add it
else "\"%" ^ P.print_reg_name a ^ "\", " ^ aux q
in aux [rRax; rRbx; rRcx; rRdx; rRsi; rRdi; rRbp; rRsp; rR8; rR9; rR10; rR11; rR12; rR13; rR14; rR15] | let print_modified_registers
(n: nat)
(ret_val: option string)
(of_arg: (reg_nat n -> reg_64))
(regs_mod reserved_args: (reg_64 -> bool))
(args: list td)
= | false | null | false | let output_register a = Some? ret_val && a = rRax in
let rec input_register (i: nat) (a: reg_64) : Tot bool (decreases (n - i)) =
if i >= n then false else a = of_arg i || input_register (i + 1) a
in
let rec aux =
function
| [] -> "\"memory\", \"cc\"\n"
| a :: q ->
if not (regs_mod a) || input_register 0 a || output_register a
then aux q
else "\"%" ^ P.print_reg_name a ^ "\", " ^ aux q
in
aux [rRax; rRbx; rRcx; rRdx; rRsi; rRdi; rRbp; rRsp; rR8; rR9; rR10; rR11; rR12; rR13; rR14; rR15] | {
"checked_file": "Vale.X64.Print_Inline_s.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Print_Inline_s.fst"
} | [
"total"
] | [
"Prims.nat",
"FStar.Pervasives.Native.option",
"Prims.string",
"Vale.Interop.X64.reg_nat",
"Vale.X64.Machine_s.reg_64",
"Prims.bool",
"Prims.list",
"Vale.Interop.Base.td",
"Prims.Cons",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRdi",
"Vale.X64.Machine_s.rRbp",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR12",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rR14",
"Vale.X64.Machine_s.rR15",
"Prims.Nil",
"Prims.op_BarBar",
"Prims.op_Negation",
"Prims.op_Hat",
"Vale.X64.Print_s.print_reg_name",
"Prims.op_Subtraction",
"Prims.op_GreaterThanOrEqual",
"Prims.op_Equality",
"Prims.op_Addition",
"Prims.op_AmpAmp",
"FStar.Pervasives.Native.uu___is_Some"
] | [] | module Vale.X64.Print_Inline_s
open FStar.Mul
open FStar.List.Tot
open Vale.X64.Machine_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Instruction_s
open FStar.IO
open Vale.Interop.Base
open Vale.Interop.X64
module P = Vale.X64.Print_s
let print_rettype (ret_val:option string) = match ret_val with
| None -> "void"
| Some _ -> "uint64_t"
let print_basetype (t:base_typ) = match t with
| TUInt8 -> "uint8_t"
| TUInt16 -> "uint16_t"
| TUInt32 -> "uint32_t"
| TUInt64 -> "uint64_t"
| TUInt128 -> "ERROR"
// Returns "uint8_t arg2" or "uint64_t* arg0" for instance
let print_arg (a:td) (i:nat) (names:nat -> string) = match a with
| TD_Base src -> print_basetype src ^ " " ^ names i
| TD_Buffer src _ _ | TD_ImmBuffer src _ _ -> print_basetype src ^ " *" ^ names i
// Prints a list of args with their types, separated by a comma
let rec print_args (args:list td) (i:nat) (names:nat -> string) = match args with
| [] -> ""
| [a] -> print_arg a i names
| a::q -> print_arg a i names ^ ", " ^ print_args q (i+1) names
let rec build_reserved_args_outs (l:list instr_out) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let (_, op) = hd in
let reserved : (reg_64 -> bool) = (fun r ->
match op with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_outs tl reserved r
let rec build_reserved_args_ins (l:list instr_operand) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let reserved : (reg_64 -> bool) = (fun r ->
match hd with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_ins tl reserved r
// Traverses code, looking for instructions implicitly using registers.
// When found, mark such registers as reserved so that they are not used during implicit allocation
let rec build_reserved_args (c:code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases c) =
fun r ->
(match c with
| Ins ins -> begin
match ins with
| Instr i _ _ ->
let reserved = build_reserved_args_outs i.outs reserved in
let reserved = build_reserved_args_ins (InstrTypeRecord?.args i) reserved in
reserved r
| _ -> reserved r
end
| Block l -> (build_reserved_args_block l reserved) r
| IfElse cond ifTrue ifFalse ->
let reservedT = build_reserved_args ifTrue reserved in
build_reserved_args ifFalse reservedT r
| While cond body -> build_reserved_args body reserved r
)
and build_reserved_args_block (l:list code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r -> (
match l with
| [] -> reserved r
| hd::tl ->
let reserved = build_reserved_args hd reserved in
build_reserved_args_block tl reserved r
)
// Prints `"=&r" (name)` if an output is specified
let print_output_ret ret_val (reg_names:reg_64 -> string) (counter:nat) : list string & (reg_64 -> string) & nat
= match ret_val with
| None -> [], reg_names, counter
| Some name -> (["\"=&r\" (" ^ name ^ ")"],
// If r = rax then address it as current arg number
(fun r -> if r = 0 then string_of_int counter else reg_names r),
counter + 1)
// If the register in which a is passed is modified, we should specify `"+&r" (name)`
let print_modified_input
(n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then
(["\"+&r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1
) else ([], reg_names, counter)
// Get a list of strings corresponding to modified inputs
let rec get_modified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{i + List.Tot.length args <= n}) (ret_val:option string)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat
= match args with
| [] -> print_output_ret ret_val reg_names counter
| a::q ->
let output, reg_names, counter = print_modified_input n a i of_arg regs_mod reserved_regs reg_names counter arg_names in
let outputs, reg_names, counter = get_modified_input_strings n of_arg regs_mod reserved_regs q (i+1) ret_val reg_names counter arg_names in
output @ outputs, reg_names, counter
// Print the list of modified inputs, separated by commas
let print_modified_inputs
(n:nat)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n})
(ret_val:option string)
(reg_names:reg_64 -> string)
(counter:nat)
(arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let outputs, output_reg_names, output_nbr = get_modified_input_strings n of_arg regs_mod reserved_regs args 0 ret_val reg_names counter arg_names in
aux outputs, output_reg_names, output_nbr
// If the register in which an arg is passed is not modified, we should specify it as `"r" (name)`
let print_nonmodified_input
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(a:td) (i:nat{i < n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then ([], reg_names, counter) else
(["\"r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1)
// Get a list of strings corresponding to modified inputs
let rec get_nonmodified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{List.Tot.length args + i <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string)
= match args with
| [] -> [], reg_names, counter
| a::q ->
let input, reg_names, counter = print_nonmodified_input n of_arg regs_mod reserved_regs a i reg_names counter arg_names in
let inputs, reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs q (i+1) reg_names counter arg_names in
input @ inputs, reg_names, counter
let print_nonmodified_inputs
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let inputs, input_reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs args 0 reg_names counter arg_names in
aux inputs, input_reg_names, counter
// Print the list of modified registers, + memory and cc
let print_modified_registers
(n:nat)
(ret_val:option string)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool) | false | false | Vale.X64.Print_Inline_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val print_modified_registers : n: Prims.nat ->
ret_val: FStar.Pervasives.Native.option Prims.string ->
of_arg: (_: Vale.Interop.X64.reg_nat n -> Vale.X64.Machine_s.reg_64) ->
regs_mod: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
reserved_args: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
args: Prims.list Vale.Interop.Base.td
-> Prims.string | [] | Vale.X64.Print_Inline_s.print_modified_registers | {
"file_name": "vale/specs/hardware/Vale.X64.Print_Inline_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
n: Prims.nat ->
ret_val: FStar.Pervasives.Native.option Prims.string ->
of_arg: (_: Vale.Interop.X64.reg_nat n -> Vale.X64.Machine_s.reg_64) ->
regs_mod: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
reserved_args: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
args: Prims.list Vale.Interop.Base.td
-> Prims.string | {
"end_col": 103,
"end_line": 204,
"start_col": 18,
"start_line": 188
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let print_modified_inputs
(n:nat)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n})
(ret_val:option string)
(reg_names:reg_64 -> string)
(counter:nat)
(arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let outputs, output_reg_names, output_nbr = get_modified_input_strings n of_arg regs_mod reserved_regs args 0 ret_val reg_names counter arg_names in
aux outputs, output_reg_names, output_nbr | let print_modified_inputs
(n: nat)
(of_arg: (reg_nat n -> reg_64))
(regs_mod reserved_regs: (reg_64 -> bool))
(args: list td {List.Tot.length args <= n})
(ret_val: option string)
(reg_names: (reg_64 -> string))
(counter: nat)
(arg_names: (nat -> string))
= | false | null | false | let rec aux =
function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let outputs, output_reg_names, output_nbr =
get_modified_input_strings n of_arg regs_mod reserved_regs args 0 ret_val reg_names counter
arg_names
in
aux outputs, output_reg_names, output_nbr | {
"checked_file": "Vale.X64.Print_Inline_s.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Print_Inline_s.fst"
} | [
"total"
] | [
"Prims.nat",
"Vale.Interop.X64.reg_nat",
"Vale.X64.Machine_s.reg_64",
"Prims.bool",
"Prims.list",
"Vale.Interop.Base.td",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.List.Tot.Base.length",
"FStar.Pervasives.Native.option",
"Prims.string",
"FStar.Pervasives.Native.Mktuple3",
"FStar.Pervasives.Native.tuple3",
"Vale.X64.Print_Inline_s.get_modified_input_strings",
"Prims.op_Hat"
] | [] | module Vale.X64.Print_Inline_s
open FStar.Mul
open FStar.List.Tot
open Vale.X64.Machine_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Instruction_s
open FStar.IO
open Vale.Interop.Base
open Vale.Interop.X64
module P = Vale.X64.Print_s
let print_rettype (ret_val:option string) = match ret_val with
| None -> "void"
| Some _ -> "uint64_t"
let print_basetype (t:base_typ) = match t with
| TUInt8 -> "uint8_t"
| TUInt16 -> "uint16_t"
| TUInt32 -> "uint32_t"
| TUInt64 -> "uint64_t"
| TUInt128 -> "ERROR"
// Returns "uint8_t arg2" or "uint64_t* arg0" for instance
let print_arg (a:td) (i:nat) (names:nat -> string) = match a with
| TD_Base src -> print_basetype src ^ " " ^ names i
| TD_Buffer src _ _ | TD_ImmBuffer src _ _ -> print_basetype src ^ " *" ^ names i
// Prints a list of args with their types, separated by a comma
let rec print_args (args:list td) (i:nat) (names:nat -> string) = match args with
| [] -> ""
| [a] -> print_arg a i names
| a::q -> print_arg a i names ^ ", " ^ print_args q (i+1) names
let rec build_reserved_args_outs (l:list instr_out) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let (_, op) = hd in
let reserved : (reg_64 -> bool) = (fun r ->
match op with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_outs tl reserved r
let rec build_reserved_args_ins (l:list instr_operand) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let reserved : (reg_64 -> bool) = (fun r ->
match hd with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_ins tl reserved r
// Traverses code, looking for instructions implicitly using registers.
// When found, mark such registers as reserved so that they are not used during implicit allocation
let rec build_reserved_args (c:code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases c) =
fun r ->
(match c with
| Ins ins -> begin
match ins with
| Instr i _ _ ->
let reserved = build_reserved_args_outs i.outs reserved in
let reserved = build_reserved_args_ins (InstrTypeRecord?.args i) reserved in
reserved r
| _ -> reserved r
end
| Block l -> (build_reserved_args_block l reserved) r
| IfElse cond ifTrue ifFalse ->
let reservedT = build_reserved_args ifTrue reserved in
build_reserved_args ifFalse reservedT r
| While cond body -> build_reserved_args body reserved r
)
and build_reserved_args_block (l:list code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r -> (
match l with
| [] -> reserved r
| hd::tl ->
let reserved = build_reserved_args hd reserved in
build_reserved_args_block tl reserved r
)
// Prints `"=&r" (name)` if an output is specified
let print_output_ret ret_val (reg_names:reg_64 -> string) (counter:nat) : list string & (reg_64 -> string) & nat
= match ret_val with
| None -> [], reg_names, counter
| Some name -> (["\"=&r\" (" ^ name ^ ")"],
// If r = rax then address it as current arg number
(fun r -> if r = 0 then string_of_int counter else reg_names r),
counter + 1)
// If the register in which a is passed is modified, we should specify `"+&r" (name)`
let print_modified_input
(n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then
(["\"+&r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1
) else ([], reg_names, counter)
// Get a list of strings corresponding to modified inputs
let rec get_modified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{i + List.Tot.length args <= n}) (ret_val:option string)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat
= match args with
| [] -> print_output_ret ret_val reg_names counter
| a::q ->
let output, reg_names, counter = print_modified_input n a i of_arg regs_mod reserved_regs reg_names counter arg_names in
let outputs, reg_names, counter = get_modified_input_strings n of_arg regs_mod reserved_regs q (i+1) ret_val reg_names counter arg_names in
output @ outputs, reg_names, counter
// Print the list of modified inputs, separated by commas
let print_modified_inputs
(n:nat)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n})
(ret_val:option string)
(reg_names:reg_64 -> string) | false | false | Vale.X64.Print_Inline_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val print_modified_inputs : n: Prims.nat ->
of_arg: (_: Vale.Interop.X64.reg_nat n -> Vale.X64.Machine_s.reg_64) ->
regs_mod: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
reserved_regs: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
args: Prims.list Vale.Interop.Base.td {FStar.List.Tot.Base.length args <= n} ->
ret_val: FStar.Pervasives.Native.option Prims.string ->
reg_names: (_: Vale.X64.Machine_s.reg_64 -> Prims.string) ->
counter: Prims.nat ->
arg_names: (_: Prims.nat -> Prims.string)
-> (Prims.string * (_: Vale.X64.Machine_s.reg_64 -> Prims.string)) * Prims.nat | [] | Vale.X64.Print_Inline_s.print_modified_inputs | {
"file_name": "vale/specs/hardware/Vale.X64.Print_Inline_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
n: Prims.nat ->
of_arg: (_: Vale.Interop.X64.reg_nat n -> Vale.X64.Machine_s.reg_64) ->
regs_mod: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
reserved_regs: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
args: Prims.list Vale.Interop.Base.td {FStar.List.Tot.Base.length args <= n} ->
ret_val: FStar.Pervasives.Native.option Prims.string ->
reg_names: (_: Vale.X64.Machine_s.reg_64 -> Prims.string) ->
counter: Prims.nat ->
arg_names: (_: Prims.nat -> Prims.string)
-> (Prims.string * (_: Vale.X64.Machine_s.reg_64 -> Prims.string)) * Prims.nat | {
"end_col": 43,
"end_line": 148,
"start_col": 29,
"start_line": 141
} |
|
Prims.Tot | val print_cmp (c: ocmp) (counter: int) (p: P.printer) : string | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let print_cmp (c:ocmp) (counter:int) (p:P.printer) : string =
let print_ops (o1:operand64) (o2:operand64) : string =
let first, second = p.P.op_order (P.print_operand o1 p) (P.print_operand o2 p) in
" cmp " ^ first ^ ", " ^ second ^ "\n"
in
match c with
| OEq o1 o2 -> " \"" ^ print_ops o1 o2 ^ " je " ^ "L" ^ string_of_int counter ^ ";\"\n"
| ONe o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jne "^ "L" ^ string_of_int counter ^ ";\"\n"
| OLe o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jbe "^ "L" ^ string_of_int counter ^ ";\"\n"
| OGe o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jae "^ "L" ^ string_of_int counter ^ ";\"\n"
| OLt o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jb " ^ "L" ^ string_of_int counter ^ ";\"\n"
| OGt o1 o2 -> " \"" ^ print_ops o1 o2 ^ " ja " ^ "L" ^ string_of_int counter ^ ";\"\n" | val print_cmp (c: ocmp) (counter: int) (p: P.printer) : string
let print_cmp (c: ocmp) (counter: int) (p: P.printer) : string = | false | null | false | let print_ops (o1 o2: operand64) : string =
let first, second = p.P.op_order (P.print_operand o1 p) (P.print_operand o2 p) in
" cmp " ^ first ^ ", " ^ second ^ "\n"
in
match c with
| OEq o1 o2 -> " \"" ^ print_ops o1 o2 ^ " je " ^ "L" ^ string_of_int counter ^ ";\"\n"
| ONe o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jne " ^ "L" ^ string_of_int counter ^ ";\"\n"
| OLe o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jbe " ^ "L" ^ string_of_int counter ^ ";\"\n"
| OGe o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jae " ^ "L" ^ string_of_int counter ^ ";\"\n"
| OLt o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jb " ^ "L" ^ string_of_int counter ^ ";\"\n"
| OGt o1 o2 -> " \"" ^ print_ops o1 o2 ^ " ja " ^ "L" ^ string_of_int counter ^ ";\"\n" | {
"checked_file": "Vale.X64.Print_Inline_s.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Print_Inline_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_Semantics_s.ocmp",
"Prims.int",
"Vale.X64.Print_s.printer",
"Vale.X64.Machine_s.operand64",
"Prims.b2t",
"Prims.op_Negation",
"Prims.op_BarBar",
"Vale.X64.Machine_s.uu___is_OMem",
"Vale.X64.Machine_s.nat64",
"Vale.X64.Machine_s.reg_64",
"Vale.X64.Machine_s.uu___is_OStack",
"Prims.op_Hat",
"Prims.string_of_int",
"Prims.string",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.Print_s.__proj__Mkprinter__item__op_order",
"Vale.X64.Print_s.print_operand"
] | [] | module Vale.X64.Print_Inline_s
open FStar.Mul
open FStar.List.Tot
open Vale.X64.Machine_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Instruction_s
open FStar.IO
open Vale.Interop.Base
open Vale.Interop.X64
module P = Vale.X64.Print_s
let print_rettype (ret_val:option string) = match ret_val with
| None -> "void"
| Some _ -> "uint64_t"
let print_basetype (t:base_typ) = match t with
| TUInt8 -> "uint8_t"
| TUInt16 -> "uint16_t"
| TUInt32 -> "uint32_t"
| TUInt64 -> "uint64_t"
| TUInt128 -> "ERROR"
// Returns "uint8_t arg2" or "uint64_t* arg0" for instance
let print_arg (a:td) (i:nat) (names:nat -> string) = match a with
| TD_Base src -> print_basetype src ^ " " ^ names i
| TD_Buffer src _ _ | TD_ImmBuffer src _ _ -> print_basetype src ^ " *" ^ names i
// Prints a list of args with their types, separated by a comma
let rec print_args (args:list td) (i:nat) (names:nat -> string) = match args with
| [] -> ""
| [a] -> print_arg a i names
| a::q -> print_arg a i names ^ ", " ^ print_args q (i+1) names
let rec build_reserved_args_outs (l:list instr_out) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let (_, op) = hd in
let reserved : (reg_64 -> bool) = (fun r ->
match op with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_outs tl reserved r
let rec build_reserved_args_ins (l:list instr_operand) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let reserved : (reg_64 -> bool) = (fun r ->
match hd with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_ins tl reserved r
// Traverses code, looking for instructions implicitly using registers.
// When found, mark such registers as reserved so that they are not used during implicit allocation
let rec build_reserved_args (c:code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases c) =
fun r ->
(match c with
| Ins ins -> begin
match ins with
| Instr i _ _ ->
let reserved = build_reserved_args_outs i.outs reserved in
let reserved = build_reserved_args_ins (InstrTypeRecord?.args i) reserved in
reserved r
| _ -> reserved r
end
| Block l -> (build_reserved_args_block l reserved) r
| IfElse cond ifTrue ifFalse ->
let reservedT = build_reserved_args ifTrue reserved in
build_reserved_args ifFalse reservedT r
| While cond body -> build_reserved_args body reserved r
)
and build_reserved_args_block (l:list code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r -> (
match l with
| [] -> reserved r
| hd::tl ->
let reserved = build_reserved_args hd reserved in
build_reserved_args_block tl reserved r
)
// Prints `"=&r" (name)` if an output is specified
let print_output_ret ret_val (reg_names:reg_64 -> string) (counter:nat) : list string & (reg_64 -> string) & nat
= match ret_val with
| None -> [], reg_names, counter
| Some name -> (["\"=&r\" (" ^ name ^ ")"],
// If r = rax then address it as current arg number
(fun r -> if r = 0 then string_of_int counter else reg_names r),
counter + 1)
// If the register in which a is passed is modified, we should specify `"+&r" (name)`
let print_modified_input
(n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then
(["\"+&r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1
) else ([], reg_names, counter)
// Get a list of strings corresponding to modified inputs
let rec get_modified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{i + List.Tot.length args <= n}) (ret_val:option string)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat
= match args with
| [] -> print_output_ret ret_val reg_names counter
| a::q ->
let output, reg_names, counter = print_modified_input n a i of_arg regs_mod reserved_regs reg_names counter arg_names in
let outputs, reg_names, counter = get_modified_input_strings n of_arg regs_mod reserved_regs q (i+1) ret_val reg_names counter arg_names in
output @ outputs, reg_names, counter
// Print the list of modified inputs, separated by commas
let print_modified_inputs
(n:nat)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n})
(ret_val:option string)
(reg_names:reg_64 -> string)
(counter:nat)
(arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let outputs, output_reg_names, output_nbr = get_modified_input_strings n of_arg regs_mod reserved_regs args 0 ret_val reg_names counter arg_names in
aux outputs, output_reg_names, output_nbr
// If the register in which an arg is passed is not modified, we should specify it as `"r" (name)`
let print_nonmodified_input
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(a:td) (i:nat{i < n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then ([], reg_names, counter) else
(["\"r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1)
// Get a list of strings corresponding to modified inputs
let rec get_nonmodified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{List.Tot.length args + i <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string)
= match args with
| [] -> [], reg_names, counter
| a::q ->
let input, reg_names, counter = print_nonmodified_input n of_arg regs_mod reserved_regs a i reg_names counter arg_names in
let inputs, reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs q (i+1) reg_names counter arg_names in
input @ inputs, reg_names, counter
let print_nonmodified_inputs
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let inputs, input_reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs args 0 reg_names counter arg_names in
aux inputs, input_reg_names, counter
// Print the list of modified registers, + memory and cc
let print_modified_registers
(n:nat)
(ret_val:option string)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_args:reg_64 -> bool)
(args:list td) =
// This register was already specified as output
let output_register a = Some? ret_val && a = rRax in
let rec input_register (i:nat) (a:reg_64) : Tot bool (decreases (n-i)) =
if i >= n then false
else
a = of_arg i // This register was already specified for the i-th argument
|| input_register (i+1) a
in
let rec aux = function
| [] -> "\"memory\", \"cc\"\n"
| a::q ->
// This register is not modified, or was already specified as input or output: we skip it
if not (regs_mod a) || input_register 0 a || output_register a then aux q
// Register not modified or already specified in inputs, we add it
else "\"%" ^ P.print_reg_name a ^ "\", " ^ aux q
in aux [rRax; rRbx; rRcx; rRdx; rRsi; rRdi; rRbp; rRsp; rR8; rR9; rR10; rR11; rR12; rR13; rR14; rR15]
// Prints "register uint64_t *argi_r __asm__("[reg]") = argi;\n"
let print_explicit_register_arg (n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (reserved:reg_64 -> bool) (names:nat -> string) =
let ty = match a with
| TD_Base _ -> "uint64_t "
| _ -> "uint64_t *"
in
if reserved (of_arg i) then
// If the associated register is reserved, we really this argument in it. For instance if it is Rdx and we have Mul(x) instructions
true, " register " ^ ty ^ names i ^ "_r __asm__(\"" ^ P.print_reg_name (of_arg i) ^ "\") = " ^ names i ^ ";\n"
else false, ""
let rec print_explicit_register_args (n:nat) (args:list td) (i:nat{i + List.length args = n}) (of_arg:reg_nat n -> reg_64) (reserved:reg_64 -> bool) (names:nat -> string) =
match args with
| [] -> false, ""
| a::q ->
let was_explicit, explicit_str = print_explicit_register_arg n a i of_arg reserved names in
let are_explicit, rest_str = print_explicit_register_args n q (i+1) of_arg reserved names in
was_explicit || are_explicit, explicit_str ^ rest_str
// If we have a return parameter with a reserved register, print "register uint64_t [name] __asm__("rax");\n"
let print_register_ret (reserved:reg_64 -> bool) = function
| None -> ""
| Some name -> if reserved rRax then " register uint64_t " ^ name ^ " __asm__(\"rax\");\n" else " uint64_t " ^ name ^ ";\n"
(* This is a copy from X64.Print_s, and should remain in sync. The difference is that | false | true | Vale.X64.Print_Inline_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val print_cmp (c: ocmp) (counter: int) (p: P.printer) : string | [] | Vale.X64.Print_Inline_s.print_cmp | {
"file_name": "vale/specs/hardware/Vale.X64.Print_Inline_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | c: Vale.X64.Machine_Semantics_s.ocmp -> counter: Prims.int -> p: Vale.X64.Print_s.printer
-> Prims.string | {
"end_col": 93,
"end_line": 243,
"start_col": 61,
"start_line": 232
} |
Prims.Tot | val get_modified_input_strings
(n: nat)
(of_arg: (reg_nat n -> reg_64))
(regs_mod reserved_regs: (reg_64 -> bool))
(args: list td)
(i: nat{i + List.Tot.length args <= n})
(ret_val: option string)
(reg_names: (reg_64 -> string))
(counter: nat)
(arg_names: (nat -> string))
: list string & (reg_64 -> string) & nat | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec get_modified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{i + List.Tot.length args <= n}) (ret_val:option string)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat
= match args with
| [] -> print_output_ret ret_val reg_names counter
| a::q ->
let output, reg_names, counter = print_modified_input n a i of_arg regs_mod reserved_regs reg_names counter arg_names in
let outputs, reg_names, counter = get_modified_input_strings n of_arg regs_mod reserved_regs q (i+1) ret_val reg_names counter arg_names in
output @ outputs, reg_names, counter | val get_modified_input_strings
(n: nat)
(of_arg: (reg_nat n -> reg_64))
(regs_mod reserved_regs: (reg_64 -> bool))
(args: list td)
(i: nat{i + List.Tot.length args <= n})
(ret_val: option string)
(reg_names: (reg_64 -> string))
(counter: nat)
(arg_names: (nat -> string))
: list string & (reg_64 -> string) & nat
let rec get_modified_input_strings
(n: nat)
(of_arg: (reg_nat n -> reg_64))
(regs_mod reserved_regs: (reg_64 -> bool))
(args: list td)
(i: nat{i + List.Tot.length args <= n})
(ret_val: option string)
(reg_names: (reg_64 -> string))
(counter: nat)
(arg_names: (nat -> string))
: list string & (reg_64 -> string) & nat = | false | null | false | match args with
| [] -> print_output_ret ret_val reg_names counter
| a :: q ->
let output, reg_names, counter =
print_modified_input n a i of_arg regs_mod reserved_regs reg_names counter arg_names
in
let outputs, reg_names, counter =
get_modified_input_strings n of_arg regs_mod reserved_regs q (i + 1) ret_val reg_names counter
arg_names
in
output @ outputs, reg_names, counter | {
"checked_file": "Vale.X64.Print_Inline_s.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Print_Inline_s.fst"
} | [
"total"
] | [
"Prims.nat",
"Vale.Interop.X64.reg_nat",
"Vale.X64.Machine_s.reg_64",
"Prims.bool",
"Prims.list",
"Vale.Interop.Base.td",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"FStar.List.Tot.Base.length",
"FStar.Pervasives.Native.option",
"Prims.string",
"Vale.X64.Print_Inline_s.print_output_ret",
"FStar.Pervasives.Native.Mktuple3",
"FStar.List.Tot.Base.op_At",
"FStar.Pervasives.Native.tuple3",
"Vale.X64.Print_Inline_s.get_modified_input_strings",
"Vale.X64.Print_Inline_s.print_modified_input"
] | [] | module Vale.X64.Print_Inline_s
open FStar.Mul
open FStar.List.Tot
open Vale.X64.Machine_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Instruction_s
open FStar.IO
open Vale.Interop.Base
open Vale.Interop.X64
module P = Vale.X64.Print_s
let print_rettype (ret_val:option string) = match ret_val with
| None -> "void"
| Some _ -> "uint64_t"
let print_basetype (t:base_typ) = match t with
| TUInt8 -> "uint8_t"
| TUInt16 -> "uint16_t"
| TUInt32 -> "uint32_t"
| TUInt64 -> "uint64_t"
| TUInt128 -> "ERROR"
// Returns "uint8_t arg2" or "uint64_t* arg0" for instance
let print_arg (a:td) (i:nat) (names:nat -> string) = match a with
| TD_Base src -> print_basetype src ^ " " ^ names i
| TD_Buffer src _ _ | TD_ImmBuffer src _ _ -> print_basetype src ^ " *" ^ names i
// Prints a list of args with their types, separated by a comma
let rec print_args (args:list td) (i:nat) (names:nat -> string) = match args with
| [] -> ""
| [a] -> print_arg a i names
| a::q -> print_arg a i names ^ ", " ^ print_args q (i+1) names
let rec build_reserved_args_outs (l:list instr_out) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let (_, op) = hd in
let reserved : (reg_64 -> bool) = (fun r ->
match op with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_outs tl reserved r
let rec build_reserved_args_ins (l:list instr_operand) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let reserved : (reg_64 -> bool) = (fun r ->
match hd with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_ins tl reserved r
// Traverses code, looking for instructions implicitly using registers.
// When found, mark such registers as reserved so that they are not used during implicit allocation
let rec build_reserved_args (c:code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases c) =
fun r ->
(match c with
| Ins ins -> begin
match ins with
| Instr i _ _ ->
let reserved = build_reserved_args_outs i.outs reserved in
let reserved = build_reserved_args_ins (InstrTypeRecord?.args i) reserved in
reserved r
| _ -> reserved r
end
| Block l -> (build_reserved_args_block l reserved) r
| IfElse cond ifTrue ifFalse ->
let reservedT = build_reserved_args ifTrue reserved in
build_reserved_args ifFalse reservedT r
| While cond body -> build_reserved_args body reserved r
)
and build_reserved_args_block (l:list code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r -> (
match l with
| [] -> reserved r
| hd::tl ->
let reserved = build_reserved_args hd reserved in
build_reserved_args_block tl reserved r
)
// Prints `"=&r" (name)` if an output is specified
let print_output_ret ret_val (reg_names:reg_64 -> string) (counter:nat) : list string & (reg_64 -> string) & nat
= match ret_val with
| None -> [], reg_names, counter
| Some name -> (["\"=&r\" (" ^ name ^ ")"],
// If r = rax then address it as current arg number
(fun r -> if r = 0 then string_of_int counter else reg_names r),
counter + 1)
// If the register in which a is passed is modified, we should specify `"+&r" (name)`
let print_modified_input
(n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then
(["\"+&r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1
) else ([], reg_names, counter)
// Get a list of strings corresponding to modified inputs
let rec get_modified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{i + List.Tot.length args <= n}) (ret_val:option string) | false | false | Vale.X64.Print_Inline_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val get_modified_input_strings
(n: nat)
(of_arg: (reg_nat n -> reg_64))
(regs_mod reserved_regs: (reg_64 -> bool))
(args: list td)
(i: nat{i + List.Tot.length args <= n})
(ret_val: option string)
(reg_names: (reg_64 -> string))
(counter: nat)
(arg_names: (nat -> string))
: list string & (reg_64 -> string) & nat | [
"recursion"
] | Vale.X64.Print_Inline_s.get_modified_input_strings | {
"file_name": "vale/specs/hardware/Vale.X64.Print_Inline_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
n: Prims.nat ->
of_arg: (_: Vale.Interop.X64.reg_nat n -> Vale.X64.Machine_s.reg_64) ->
regs_mod: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
reserved_regs: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
args: Prims.list Vale.Interop.Base.td ->
i: Prims.nat{i + FStar.List.Tot.Base.length args <= n} ->
ret_val: FStar.Pervasives.Native.option Prims.string ->
reg_names: (_: Vale.X64.Machine_s.reg_64 -> Prims.string) ->
counter: Prims.nat ->
arg_names: (_: Prims.nat -> Prims.string)
-> (Prims.list Prims.string * (_: Vale.X64.Machine_s.reg_64 -> Prims.string)) * Prims.nat | {
"end_col": 42,
"end_line": 129,
"start_col": 4,
"start_line": 124
} |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.